Diff [933f32f2ae9703d54327e4727aceb5746433092d:6a9d4b47126a548dbbe35dc77b13769c972aa0a9] for / – Cforall

.gitignore

-              r933f32f
+              r6a9d4b4
 config.py
 stamp-h1
-libtool
 /Makefile
 **/Makefile
 …
 libcfa/arm-nolib/
 # generated by bison and lex from parser.yy and lex.ll
 src/Parser/parser.output

Jenkins/FullBuild

-              r933f32f
+              r6a9d4b4
                                 parallel (
                                         gcc_6_x64: { trigger_build( 'gcc-6',   'x64' ) },
                                         gcc_6_x86: { trigger_build( 'gcc-6',   'x86' ) },
                                         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' ) },
+                                        gcc_6_x64: { trigger_build( 'gcc-6',   'x64', true  ) },
+                                        gcc_6_x86: { trigger_build( 'gcc-6',   'x86', true  ) },
+                                        gcc_5_x64: { trigger_build( 'gcc-5',   'x64', false ) },
+                                        gcc_5_x86: { trigger_build( 'gcc-5',   'x86', false ) },
+                                        clang_x64: { trigger_build( 'clang',   'x64', false ) },
+                                        clang_x86: { trigger_build( 'clang',   'x86', false ) },
+                                )
+                        }
+                        //Push latest changes to do-lang repo
+                        push_build()
+                }
-                promote_email(true)
+        }
 …
                 //Send email to notify the failure
                 promote_email(false)
+                promote_failure_email()
+        }
 …
 //===========================================================================================================
 def trigger_build(String cc, String arch) {
+def trigger_build(String cc, String arch, Boolean publish) {
         def result = build job: 'Cforall/master',               \
                 parameters: [                                           \
 …
                         [$class: 'BooleanParameterValue',               \
                           name: 'Publish',                              \
                           value: true],                                 \
+                          value: publish],                              \
                         [$class: 'BooleanParameterValue',               \
                           name: 'Silent',                               \
 …
                 sh("wget -q -O - http://localhost:8084/jenkins/job/Cforall/job/master/${result.number}/consoleText")
                 error(result.result)
+        }
+}
+def push_build() {
+        //Don't use the build_stage function which outputs the compiler
+        stage('Push') {
+                status_prefix = 'Push'
+                def out_dir = pwd tmp: true
+                sh "mkdir -p ${out_dir}"
+                //checkout the code to make sure this is a valid git repo
+                checkout scm
+                collect_git_info()
+                //parse git logs to find what changed
+                sh "git remote > ${out_dir}/GIT_REMOTE"
+                git_remote = readFile("${out_dir}/GIT_REMOTE")
+                remoteDoLangExists = git_remote.contains("DoLang")
+                if( !remoteDoLangExists ) {
+                        sh 'git remote add DoLang git@gitlab.do-lang.org:internal/cfa-cc.git'
+                }
+                //sh "GIT_SSH_COMMAND=\"ssh -v\" git push DoLang ${gitRefNewValue}:master"
+                echo('BUILD NOT PUSH SINCE DO-LANG SERVER WAS DOWN')
+        }
+}
 …
 //Email notification on a full build failure
 def promote_email(boolean success) {
+def promote_failure_email() {
         echo('notifying users')
-        def result = success ? "PROMOTE - SUCCESS" : "PROMOTE - FAILURE"
         //Since tokenizer doesn't work, figure stuff out from the environnement variables and command line
         //Configurations for email format
+        def email_subject = "[cforall git][${result}]"
+        def email_body = """<p>This is an automated email from the Jenkins build machine. It was
+generated following the result of the C\u2200 nightly build.</p>
+        def email_subject = "[cforall git][PROMOTE - FAILURE]"
+        def email_body = """This is an automated email from the Jenkins build machine. It was
+generated because of a git hooks/post-receive script following
+a ref change was pushed to the repository containing
+the project "UNNAMED PROJECT".
+<p>Check console output at ${env.BUILD_URL} to view the results.</p>
+Check console output at ${env.BUILD_URL} to view the results.
+<p>- Status --------------------------------------------------------------</p>
+- Status --------------------------------------------------------------
+<p>${result}</p>
+<p>- Performance ---------------------------------------------------------</p>
+<img src="https://cforall.uwaterloo.ca/jenkins/job/Cforall/job/master/plot/Compilation/getPlot?index=0" >
+<p>- Logs ----------------------------------------------------------------</p>
+PROMOTE FAILURE
 """
 …
         //send email notification
         emailext body: email_body, subject: email_subject, to: email_to, attachLog: !success
+        emailext body: email_body, subject: email_subject, to: email_to, attachLog: true
+}

Jenkinsfile

-              r933f32f
+              r6a9d4b4
 #!groovy
-import groovy.transform.Field
 //===========================================================================================================
 …
                 wrap([$class: 'TimestamperBuildWrapper']) {
+                        notify_server(0)
                         Settings = prepare_build()
 …
                                 checkout()
+                                notify_server(0)
                                 build()
 …
                         BuildDir  = pwd tmp: true
                         SrcDir    = pwd tmp: false
+                        notify_server(45)
+                }
+        }
 …
         finally {
                 //Send email with final results if this is not a full build
+                email(log_needed)
+                if( Settings && !Settings.Silent ) {
+                        email(log_needed, Settings.IsSandbox)
+                }
                 echo 'Build Completed'
 …
                         //Also specify the compiler by hand
                         targets=""
                         if( Settings.RunAllTests || Settings.RunBenchmark ) {
+                        if( Settings.RunAllTests ) {
                                 targets="--with-target-hosts='host:debug,host:nodebug'"
                         } else {
 …
                 dir (BuildDir) {
                         //Append bench results
                         sh "make --no-print-directory -C benchmark jenkins"
+                        sh "${SrcDir}/benchmark/jenkins.sh ${Settings.GitNewRef} ${Settings.Architecture} ${BuildDir}/bench.json"
+                }
+        }
 …
         build_stage('Publish') {
+                if( Settings.Publish && !Settings.RunBenchmark ) { echo 'No results to publish!!!' }
+                def groupCompile = new PlotGroup('Compilation', 'seconds', true)
+                def groupConcurrency = new PlotGroup('Concurrency', 'nanoseconds', false)
+                if( !Settings.Publish ) return
                 //Then publish the results
+                do_plot(Settings.RunBenchmark && Settings.Publish, 'compile'  , groupCompile    , 'Compilation')
+                do_plot(Settings.RunBenchmark && Settings.Publish, 'ctxswitch', groupConcurrency, 'Context Switching')
+                do_plot(Settings.RunBenchmark && Settings.Publish, 'mutex'    , groupConcurrency, 'Mutual Exclusion')
+                do_plot(Settings.RunBenchmark && Settings.Publish, 'signal'   , groupConcurrency, 'Internal and External Scheduling')
+                sh 'curl --silent --show-error -H \'Content-Type: application/json\' --data @${BuildDir}/bench.json https://cforall.uwaterloo.ca:8082/jenkins/publish > /dev/null || true'
+        }
+}
 …
         return """
-<pre>
 The branch ${env.BRANCH_NAME} has been updated.
 ${gitUpdate}
+</pre>
+<p>Check console output at ${env.BUILD_URL} to view the results.</p>
+<p>- Status --------------------------------------------------------------</p>
+<p>BUILD# ${env.BUILD_NUMBER} - ${currentBuild.result}</p>
+<p>- Log -----------------------------------------------------------------</p>
+<pre>
+Check console output at ${env.BUILD_URL} to view the results.
+- Status --------------------------------------------------------------
+BUILD# ${env.BUILD_NUMBER} - ${currentBuild.result}
+- Log -----------------------------------------------------------------
 ${gitLog}
+</pre>
+<p>-----------------------------------------------------------------------</p>
+<pre>
+-----------------------------------------------------------------------
 Summary of changes:
 ${gitDiff}
-</pre>
 """
+}
 //Standard build email notification
 def email(boolean log) {
+def email(boolean log, boolean bIsSandbox) {
         //Since tokenizer doesn't work, figure stuff out from the environnement variables and command line
         //Configurations for email format
 …
         def project_name = (env.JOB_NAME =~ /(.+)\/.+/)[0][1].toLowerCase()
         def email_subject = "[${project_name} git][BUILD# ${env.BUILD_NUMBER} - ${currentBuild.result}] - branch ${env.BRANCH_NAME}"
         def email_body = """<p>This is an automated email from the Jenkins build machine. It was
+        def email_body = """This is an automated email from the Jenkins build machine. It was
 generated because of a git hooks/post-receive script following
 a ref change which was pushed to the C\u2200 repository.</p>
+a ref change which was pushed to the Cforall repository.
 """ + GitLogMessage()
         def email_to = !Settings.IsSandbox ? "cforall@lists.uwaterloo.ca" : "tdelisle@uwaterloo.ca"
         if( Settings && !Settings.Silent ) {
+        def email_to = "cforall@lists.uwaterloo.ca"
+        if( Settings && !Settings.IsSandbox ) {
                 //send email notification
                 emailext body: email_body, subject: email_subject, to: email_to, attachLog: log
 …
+                }
-                this.IsSandbox          = (branch == "jenkins-sandbox")
                 this.RunAllTests        = param.RunAllTests
                 this.RunBenchmark       = param.RunBenchmark
 …
                 this.Publish            = param.Publish
                 this.Silent             = param.Silent
+                this.IsSandbox          = (branch == "jenkins-sandbox")
                 def full = param.RunAllTests ? " (Full)" : ""
 …
                 this.GitNewRef = ''
                 this.GitOldRef = ''
+        }
+}
-class PlotGroup implements Serializable {
-        public String name
-        public String unit
-        public boolean log
-        PlotGroup(String name, String unit, boolean log) {
-                this.name = name
-                this.unit = unit
-                this.log = log
+        }
+}
 …
+}
+def notify_server(int wait) {
+        sh """curl --silent --show-error --data "wait=${wait}" -X POST https://cforall.uwaterloo.ca:8082/jenkins/notify > /dev/null || true"""
+        return
+}
 def make_doc() {
         def err = null
 …
+        }
+}
-def do_plot(boolean new_data, String file, PlotGroup group, String title) {
-        if(new_data) {
-                echo "Publishing new data"
+        }
-        def series = new_data ? [[
-                                file: "${file}.csv",
-                                exclusionValues: '',
-                                displayTableFlag: false,
-                                inclusionFlag: 'OFF',
-                                url: ''
-                        ]] : [];
-        echo "file is ${BuildDir}/benchmark/${file}.csv, group ${group}, title ${title}"
-        dir("${BuildDir}/benchmark/") {
-                plot csvFileName: "cforall-${env.BRANCH_NAME}-${file}.csv",
-                        csvSeries: series,
-                        group: "${group.name}",
-                        title: "${title}",
-                        style: 'lineSimple',
-                        exclZero: false,
-                        keepRecords: false,
-                        logarithmic: group.log,
-                        numBuilds: '120',
-                        useDescr: true,
-                        yaxis: group.unit,
-                        yaxisMaximum: '',
-                        yaxisMinimum: ''
+        }
+}

Makefile.am

-              r933f32f
+              r6a9d4b4
 ## Created On       : Sun May 31 22:14:18 2015
 ## Last Modified By : Peter A. Buhr
 ## Last Modified On : Sat Feb  2 16:54:42 2019
 ## Update Count     : 21
+## Last Modified On : Wed Dec 14 14:20:48 2016
+## Update Count     : 15
 ###############################################################################
 …
 ACLOCAL_AMFLAGS  = -I automake
+MAINTAINERCLEANFILES = lib/* bin/* tests/.deps/* tests/.out/* # order important
+MAINTAINERCLEANFILES = lib/* bin/* tests/.deps/* tests/.out/*
+ # order important
 SUBDIRS = driver src . @LIBCFA_TARGET_DIRS@

Makefile.in

-              r933f32f
+              r6a9d4b4
 distcleancheck_listfiles = find . -type f -print
 ACLOCAL = @ACLOCAL@
+ALLOCA = @ALLOCA@
 AMTAR = @AMTAR@
 AM_DEFAULT_VERBOSITY = @AM_DEFAULT_VERBOSITY@
 …
 AUTOMAKE_OPTIONS = foreign    # do not require all the GNU file names
 ACLOCAL_AMFLAGS = -I automake
 MAINTAINERCLEANFILES = lib/* bin/* tests/.deps/* tests/.out/* # order important
+MAINTAINERCLEANFILES = lib/* bin/* tests/.deps/* tests/.out/*
 SUBDIRS = driver src . @LIBCFA_TARGET_DIRS@
 noinst_DATA = @LIBCFA_TARGET_MAKEFILES@
 …
 .PRECIOUS: Makefile
+ # order important
 @LIBCFA_TARGET_MAKEFILES@ : Makefile $(srcdir)/libcfa/configure

automake/cfa.m4

-              r933f32f
+              r6a9d4b4
         esac
 ])
-# http://git.savannah.gnu.org/gitweb/?p=autoconf-archive.git;a=blob_plain;f=m4/ax_check_compile_flag.m4
-AC_DEFUN([M4CFA_CHECK_COMPILE_FLAG],
-[AC_PREREQ(2.64)dnl for _AC_LANG_PREFIX and AS_VAR_IF
-AS_VAR_PUSHDEF([CACHEVAR],[m4cfa_cv_check_[]_AC_LANG_ABBREV[]flags_$4_$1])dnl
-AC_CACHE_CHECK([whether _AC_LANG compiler accepts $1], CACHEVAR, [
-        m4cfa_check_save_flags=$[]_AC_LANG_PREFIX[]FLAGS
-        _AC_LANG_PREFIX[]FLAGS="$[]_AC_LANG_PREFIX[]FLAGS $4 $1"
-        AC_COMPILE_IFELSE([m4_default([$5],[AC_LANG_PROGRAM()])],
-                [AS_VAR_SET(CACHEVAR,[yes])],
-                [AS_VAR_SET(CACHEVAR,[no])])
-        _AC_LANG_PREFIX[]FLAGS=$m4cfa_check_save_flags])
-AS_VAR_IF(CACHEVAR,yes,
-        [m4_default([$2], :)],
-        [m4_default([$3], :)])
-AS_VAR_POPDEF([CACHEVAR])dnl
-])dnl M4CFA_CHECK_COMPILE_FLAGS

benchmark/Makefile.am

-              r933f32f
+              r6a9d4b4
 include $(top_srcdir)/src/cfa.make
+AM_CFLAGS = -O2 -Wall -Wextra -Werror -I$(srcdir) -lrt -pthread
+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))
+__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_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)
+AM_CFLAGS = -O2 -Wall -I$(srcdir) -lrt -pthread
+AM_CFAFLAGS = -quiet -in-tree -nodebug
+AM_UPPFLAGS = -quiet -nodebug -multi
 TOOLSDIR = ${abs_top_builddir}/tools/
 …
 .NOTPARALLEL:
-.PHONY: compile.csv ctxswitch.csv mutex.csv signal.csv
 ## =========================================================================================================
 …
 %.runquiet :
         @+make $(basename $@) CFLAGS="-w" __quiet=quiet
+        @+make $(basename $@) CFLAGS="-w"
         @taskset -c 1 ./a.out
         @rm -f a.out
 …
 ## =========================================================================================================
-FIX_NEW_LINES = cat $@ | tr "\n" "\t" | sed -r 's/\t,/,/' | tr "\t" "\n" > $@
 jenkins$(EXEEXT):
+        @echo "{"
+        @echo -e '\t"githash": "'${githash}'",'
+        @echo -e '\t"arch": "'   ${arch}   '",'
 @DOifskipcompile@
+        @+make compile.csv
+        @echo -e '\t"compile": {'
+        @+make compile TIME_FORMAT='%e,' PRINT_FORMAT='\t\t\"%s\" :'
+        @echo -e '\t\t"dummy" : {}'
+        @echo -e '\t},'
 @DOendif@
+        @+make ctxswitch.csv
+        @+make mutex.csv
+        @+make signal.csv
+@DOifskipcompile@
+        @cat compile.csv
+@DOendif@
+        @cat ctxswitch.csv
+        @cat mutex.csv
+        @cat signal.csv
+compile.csv:
+        @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 "coroutine,thread" > $@
+        @+make ctxswitch-cfa_coroutine.runquiet >> $@ && echo -n ',' >> $@
+        @+make ctxswitch-cfa_thread.runquiet >> $@
+        @$(srcdir)/fixcsv.sh $@
+mutex.csv:
+        @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 $@
+        @echo -e '\t"ctxswitch": {'
+        @echo -en '\t\t"coroutine":'
+        @+make ctxswitch-cfa_coroutine.runquiet
+        @echo -en '\t\t,"thread":'
+        @+make ctxswitch-cfa_thread.runquiet
+        @echo -e '\t},'
+        @echo -e '\t"mutex": ['
+        @echo -en '\t\t'
+        @+make mutex-cfa1.runquiet
+        @echo -en '\t\t,'
+        @+make mutex-cfa2.runquiet
+        @echo -e '\t],'
+        @echo -e '\t"scheduling": ['
+        @echo -en '\t\t'
+        @+make signal-cfa1.runquiet
+        @echo -en '\t\t,'
+        @+make signal-cfa2.runquiet
+        @echo -en '\t\t,'
+        @+make waitfor-cfa1.runquiet
+        @echo -en '\t\t,'
+        @+make waitfor-cfa2.runquiet
+        @echo -e '\n\t],'
+        @echo -e '\t"epoch": ' $(shell date +%s)
+        @echo "}"
 ## =========================================================================================================
 loop$(EXEEXT):
         $(BENCH_V_CC)$(COMPILE) -DBENCH_N=5000000000 $(srcdir)/loop.c
+        $(AM_V_CC)$(COMPILE) -DBENCH_N=5000000000 $(srcdir)/loop.c
 function$(EXEEXT):
         $(BENCH_V_CC)$(COMPILE) -DBENCH_N=5000000000 $(srcdir)/function.c
+        $(AM_V_CC)$(COMPILE) -DBENCH_N=5000000000 $(srcdir)/function.c
 fetch_add$(EXEEXT):
+        $(BENCH_V_CC)$(COMPILE) -DBENCH_N=500000000  $(srcdir)/fetch_add.c
+tls-fetch_add$(EXEEXT):
+        $(BENCH_V_CC)$(COMPILE) -DBENCH_N=500000000  $(srcdir)/tls-fetch_add.c
+        $(AM_V_CC)$(COMPILE) -DBENCH_N=500000000  $(srcdir)/fetch_add.c
 ## =========================================================================================================
 …
         function.run                    \
         fetch_add.run                   \
-        tls-fetch_add.run                       \
         ctxswitch-pthread.run           \
         ctxswitch-cfa_coroutine.run     \
 …
 ctxswitch-kos_fibre$(EXEEXT):
         $(BENCH_V_CXX)$(CXXCOMPILE) -DBENCH_N=50000000 $(srcdir)/ctxswitch/kos_fibre.cpp  -I$(LIBFIBRE_DIR) -lfibre
+        $(AM_V_CXX)$(CXXCOMPILE) -DBENCH_N=50000000 $(srcdir)/ctxswitch/kos_fibre.cpp  -I$(LIBFIBRE_DIR) -lfibre
 ctxswitch-kos_fibre2$(EXEEXT):
         $(BENCH_V_CXX)$(CXXCOMPILE) -DBENCH_N=50000000 $(srcdir)/ctxswitch/kos_fibre2.cpp -I$(LIBFIBRE_DIR) -lfibre
+        $(AM_V_CXX)$(CXXCOMPILE) -DBENCH_N=50000000 $(srcdir)/ctxswitch/kos_fibre2.cpp -I$(LIBFIBRE_DIR) -lfibre
 endif
 …
 ctxswitch-pthread$(EXEEXT):
         $(BENCH_V_CC)$(COMPILE)    -DBENCH_N=50000000 $(srcdir)/ctxswitch/pthreads.c
+        $(AM_V_CC)$(COMPILE)    -DBENCH_N=50000000 $(srcdir)/ctxswitch/pthreads.c
 ctxswitch-cfa_coroutine$(EXEEXT):
         $(BENCH_V_CFA)$(CFACOMPILE) -DBENCH_N=50000000 $(srcdir)/ctxswitch/cfa_cor.cfa
+        $(AM_V_CFA)$(CFACOMPILE) -DBENCH_N=50000000 $(srcdir)/ctxswitch/cfa_cor.cfa
 ctxswitch-cfa_thread$(EXEEXT):
         $(BENCH_V_CFA)$(CFACOMPILE) -DBENCH_N=50000000 $(srcdir)/ctxswitch/cfa_thrd.cfa
+        $(AM_V_CFA)$(CFACOMPILE) -DBENCH_N=50000000 $(srcdir)/ctxswitch/cfa_thrd.cfa
 ctxswitch-cfa_thread2$(EXEEXT):
         $(BENCH_V_CFA)$(CFACOMPILE) -DBENCH_N=50000000 $(srcdir)/ctxswitch/cfa_thrd2.cfa
+        $(AM_V_CFA)$(CFACOMPILE) -DBENCH_N=50000000 $(srcdir)/ctxswitch/cfa_thrd2.cfa
 ctxswitch-upp_coroutine$(EXEEXT):
         $(BENCH_V_UPP)$(UPPCOMPILE) -DBENCH_N=50000000 $(srcdir)/ctxswitch/upp_cor.cc
+        $(AM_V_UPP)$(UPPCOMPILE) -DBENCH_N=50000000 $(srcdir)/ctxswitch/upp_cor.cc
 ctxswitch-upp_thread$(EXEEXT):
         $(BENCH_V_UPP)$(UPPCOMPILE) -DBENCH_N=50000000 $(srcdir)/ctxswitch/upp_thrd.cc
+        $(AM_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
+        $(AM_V_GOC)go build -o a.out $(srcdir)/ctxswitch/goroutine.go
 ctxswitch-java_thread$(EXEEXT):
         $(BENCH_V_JAVAC)javac -d $(builddir) $(srcdir)/ctxswitch/JavaThread.java
+        $(AM_V_JAVAC)javac -d $(builddir) $(srcdir)/ctxswitch/JavaThread.java
         @echo "#!/bin/sh" > a.out
         @echo "java JavaThread" >> a.out
 …
 mutex-pthread_lock$(EXEEXT):
         $(BENCH_V_CC)$(COMPILE)    -DBENCH_N=50000000 $(srcdir)/mutex/pthreads.c
+        $(AM_V_CC)$(COMPILE)    -DBENCH_N=50000000 $(srcdir)/mutex/pthreads.c
 mutex-upp$(EXEEXT):
         $(BENCH_V_UPP)$(UPPCOMPILE) -DBENCH_N=50000000 $(srcdir)/mutex/upp.cc
+        $(AM_V_UPP)$(UPPCOMPILE) -DBENCH_N=50000000 $(srcdir)/mutex/upp.cc
 mutex-cfa1$(EXEEXT):
         $(BENCH_V_CFA)$(CFACOMPILE) -DBENCH_N=5000000  $(srcdir)/mutex/cfa1.cfa
+        $(AM_V_CFA)$(CFACOMPILE) -DBENCH_N=5000000  $(srcdir)/mutex/cfa1.cfa
 mutex-cfa2$(EXEEXT):
         $(BENCH_V_CFA)$(CFACOMPILE) -DBENCH_N=5000000  $(srcdir)/mutex/cfa2.cfa
+        $(AM_V_CFA)$(CFACOMPILE) -DBENCH_N=5000000  $(srcdir)/mutex/cfa2.cfa
 mutex-cfa4$(EXEEXT):
         $(BENCH_V_CFA)$(CFACOMPILE) -DBENCH_N=5000000  $(srcdir)/mutex/cfa4.cfa
+        $(AM_V_CFA)$(CFACOMPILE) -DBENCH_N=5000000  $(srcdir)/mutex/cfa4.cfa
 mutex-java_thread$(EXEEXT):
         $(BENCH_V_JAVAC)javac -d $(builddir) $(srcdir)/mutex/JavaThread.java
+        $(AM_V_JAVAC)javac -d $(builddir) $(srcdir)/mutex/JavaThread.java
         @echo "#!/bin/sh" > a.out
         @echo "java JavaThread" >> a.out
 …
 signal-pthread_cond$(EXEEXT):
         $(BENCH_V_CC)$(COMPILE)    -DBENCH_N=500000  $(srcdir)/schedint/pthreads.c
+        $(AM_V_CC)$(COMPILE)    -DBENCH_N=500000  $(srcdir)/schedint/pthreads.c
 signal-upp$(EXEEXT):
         $(BENCH_V_UPP)$(UPPCOMPILE) -DBENCH_N=5000000 $(srcdir)/schedint/upp.cc
+        $(AM_V_UPP)$(UPPCOMPILE) -DBENCH_N=5000000 $(srcdir)/schedint/upp.cc
 signal-cfa1$(EXEEXT):
         $(BENCH_V_CFA)$(CFACOMPILE) -DBENCH_N=500000  $(srcdir)/schedint/cfa1.cfa
+        $(AM_V_CFA)$(CFACOMPILE) -DBENCH_N=500000  $(srcdir)/schedint/cfa1.cfa
 signal-cfa2$(EXEEXT):
         $(BENCH_V_CFA)$(CFACOMPILE) -DBENCH_N=500000  $(srcdir)/schedint/cfa2.cfa
+        $(AM_V_CFA)$(CFACOMPILE) -DBENCH_N=500000  $(srcdir)/schedint/cfa2.cfa
 signal-cfa4$(EXEEXT):
         $(BENCH_V_CFA)$(CFACOMPILE) -DBENCH_N=500000  $(srcdir)/schedint/cfa4.cfa
+        $(AM_V_CFA)$(CFACOMPILE) -DBENCH_N=500000  $(srcdir)/schedint/cfa4.cfa
 signal-java_thread$(EXEEXT):
         $(BENCH_V_JAVAC)javac -d $(builddir) $(srcdir)/schedint/JavaThread.java
+        $(AM_V_JAVAC)javac -d $(builddir) $(srcdir)/schedint/JavaThread.java
         @echo "#!/bin/sh" > a.out
         @echo "java JavaThread" >> a.out
 …
 waitfor-upp$(EXEEXT):
         $(BENCH_V_UPP)$(UPPCOMPILE) -DBENCH_N=5000000 $(srcdir)/schedext/upp.cc
+        $(AM_V_UPP)$(UPPCOMPILE) -DBENCH_N=5000000 $(srcdir)/schedext/upp.cc
 waitfor-cfa1$(EXEEXT):
         $(BENCH_V_CFA)$(CFACOMPILE) -DBENCH_N=500000  $(srcdir)/schedext/cfa1.cfa
+        $(AM_V_CFA)$(CFACOMPILE) -DBENCH_N=500000  $(srcdir)/schedext/cfa1.cfa
 waitfor-cfa2$(EXEEXT):
         $(BENCH_V_CFA)$(CFACOMPILE) -DBENCH_N=500000  $(srcdir)/schedext/cfa2.cfa
+        $(AM_V_CFA)$(CFACOMPILE) -DBENCH_N=500000  $(srcdir)/schedext/cfa2.cfa
 waitfor-cfa4$(EXEEXT):
         $(BENCH_V_CFA)$(CFACOMPILE) -DBENCH_N=500000  $(srcdir)/schedext/cfa4.cfa
+        $(AM_V_CFA)$(CFACOMPILE) -DBENCH_N=500000  $(srcdir)/schedext/cfa4.cfa
 ## =========================================================================================================
 …
 creation-cfa_coroutine$(EXEEXT):
         $(BENCH_V_CFA)$(CFACOMPILE) -DBENCH_N=10000000 $(srcdir)/creation/cfa_cor.cfa
+        $(AM_V_CFA)$(CFACOMPILE) -DBENCH_N=10000000 $(srcdir)/creation/cfa_cor.cfa
 creation-cfa_coroutine_eager$(EXEEXT):
         $(BENCH_V_CFA)$(CFACOMPILE) -DBENCH_N=10000000 $(srcdir)/creation/cfa_cor.cfa  -DEAGER
+        $(AM_V_CFA)$(CFACOMPILE) -DBENCH_N=10000000 $(srcdir)/creation/cfa_cor.cfa  -DEAGER
 creation-cfa_thread$(EXEEXT):
         $(BENCH_V_CFA)$(CFACOMPILE) -DBENCH_N=10000000 $(srcdir)/creation/cfa_thrd.cfa
+        $(AM_V_CFA)$(CFACOMPILE) -DBENCH_N=10000000 $(srcdir)/creation/cfa_thrd.cfa
 creation-upp_coroutine$(EXEEXT):
         $(BENCH_V_UPP)$(UPPCOMPILE) -DBENCH_N=50000000 $(srcdir)/creation/upp_cor.cc
+        $(AM_V_UPP)$(UPPCOMPILE) -DBENCH_N=50000000 $(srcdir)/creation/upp_cor.cc
 creation-upp_thread$(EXEEXT):
         $(BENCH_V_UPP)$(UPPCOMPILE) -DBENCH_N=50000000 $(srcdir)/creation/upp_thrd.cc
+        $(AM_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
+        $(AM_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
+        $(AM_V_GOC)go build -o a.out $(srcdir)/creation/goroutine.go
 creation-java_thread$(EXEEXT):
         $(BENCH_V_JAVAC)javac -d $(builddir) $(srcdir)/creation/JavaThread.java
+        $(AM_V_JAVAC)javac -d $(builddir) $(srcdir)/creation/JavaThread.java
         @echo "#!/bin/sh" > a.out
         @echo "java JavaThread" >> a.out
 …
 compile-array$(EXEEXT):
         @$(CFACOMPILE) -fsyntax-only -w $(testdir)/array.cfa
+        $(AM_V_CFA)$(CFACOMPILE) -fsyntax-only -w $(testdir)/array.cfa
 compile-attributes$(EXEEXT):
         @$(CFACOMPILE) -fsyntax-only -w $(testdir)/attributes.cfa
+        $(AM_V_CFA)$(CFACOMPILE) -fsyntax-only -w $(testdir)/attributes.cfa
 compile-empty$(EXEEXT):
         @$(CFACOMPILE) -fsyntax-only -w $(srcdir)/compile/empty.cfa
+        $(AM_V_CFA)$(CFACOMPILE) -fsyntax-only -w $(srcdir)/compile/empty.cfa
 compile-expression$(EXEEXT):
         @$(CFACOMPILE) -fsyntax-only -w $(testdir)/expression.cfa
+        $(AM_V_CFA)$(CFACOMPILE) -fsyntax-only -w $(testdir)/expression.cfa
 compile-io$(EXEEXT):
         @$(CFACOMPILE) -fsyntax-only -w $(testdir)/io1.cfa
+        $(AM_V_CFA)$(CFACOMPILE) -fsyntax-only -w $(testdir)/io1.cfa
 compile-monitor$(EXEEXT):
         @$(CFACOMPILE) -fsyntax-only -w $(testdir)/concurrent/monitor.cfa
+        $(AM_V_CFA)$(CFACOMPILE) -fsyntax-only -w $(testdir)/concurrent/monitor.cfa
 compile-operators$(EXEEXT):
         @$(CFACOMPILE) -fsyntax-only -w $(testdir)/operators.cfa
+        $(AM_V_CFA)$(CFACOMPILE) -fsyntax-only -w $(testdir)/operators.cfa
 compile-thread$(EXEEXT):
         @$(CFACOMPILE) -fsyntax-only -w $(testdir)/concurrent/thread.cfa
+        $(AM_V_CFA)$(CFACOMPILE) -fsyntax-only -w $(testdir)/concurrent/thread.cfa
 compile-typeof$(EXEEXT):
         @$(CFACOMPILE) -fsyntax-only -w $(testdir)/typeof.cfa
+        $(AM_V_CFA)$(CFACOMPILE) -fsyntax-only -w $(testdir)/typeof.cfa

benchmark/Makefile.in

-              r933f32f
+              r6a9d4b4
 DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)
 ACLOCAL = @ACLOCAL@
+ALLOCA = @ALLOCA@
 AMTAR = @AMTAR@
 AM_DEFAULT_VERBOSITY = @AM_DEFAULT_VERBOSITY@
 …
 # applies to both programs
+AM_CFLAGS = -O2 -Wall -Wextra -Werror -I$(srcdir) -lrt -pthread
+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))
+__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_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)
+AM_CFLAGS = -O2 -Wall -I$(srcdir) -lrt -pthread
+AM_CFAFLAGS = -quiet -in-tree -nodebug
+AM_UPPFLAGS = -quiet -nodebug -multi
 TOOLSDIR = ${abs_top_builddir}/tools/
 REPEAT = ${abs_top_builddir}/tools/repeat
 …
 PRINT_FORMAT = %20s: #Comments needed for spacing
 dummy_SOURCES = dummyC.c dummyCXX.cpp
-FIX_NEW_LINES = cat $@ | tr "\n" "\t" | sed -r 's/\t,/,/' | tr "\t" "\n" > $@
 CTXSWITCH_DEPEND = loop.run function.run fetch_add.run \
         tls-fetch_add.run ctxswitch-pthread.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)
+        ctxswitch-pthread.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
 …
 .NOTPARALLEL:
-.PHONY: compile.csv ctxswitch.csv mutex.csv signal.csv
 all : ctxswitch$(EXEEXT) mutex$(EXEEXT) signal$(EXEEXT) waitfor$(EXEEXT) creation$(EXEEXT)
 …
 %.runquiet :
         @+make $(basename $@) CFLAGS="-w" __quiet=quiet
+        @+make $(basename $@) CFLAGS="-w"
         @taskset -c 1 ./a.out
         @rm -f a.out
 …
 jenkins$(EXEEXT):
+        @echo "{"
+        @echo -e '\t"githash": "'${githash}'",'
+        @echo -e '\t"arch": "'   ${arch}   '",'
 @DOifskipcompile@
+        @+make compile.csv
+        @echo -e '\t"compile": {'
+        @+make compile TIME_FORMAT='%e,' PRINT_FORMAT='\t\t\"%s\" :'
+        @echo -e '\t\t"dummy" : {}'
+        @echo -e '\t},'
 @DOendif@
+        @+make ctxswitch.csv
+        @+make mutex.csv
+        @+make signal.csv
+@DOifskipcompile@
+        @cat compile.csv
+@DOendif@
+        @cat ctxswitch.csv
+        @cat mutex.csv
+        @cat signal.csv
+compile.csv:
+        @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 "coroutine,thread" > $@
+        @+make ctxswitch-cfa_coroutine.runquiet >> $@ && echo -n ',' >> $@
+        @+make ctxswitch-cfa_thread.runquiet >> $@
+        @$(srcdir)/fixcsv.sh $@
+mutex.csv:
+        @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 $@
+        @echo -e '\t"ctxswitch": {'
+        @echo -en '\t\t"coroutine":'
+        @+make ctxswitch-cfa_coroutine.runquiet
+        @echo -en '\t\t,"thread":'
+        @+make ctxswitch-cfa_thread.runquiet
+        @echo -e '\t},'
+        @echo -e '\t"mutex": ['
+        @echo -en '\t\t'
+        @+make mutex-cfa1.runquiet
+        @echo -en '\t\t,'
+        @+make mutex-cfa2.runquiet
+        @echo -e '\t],'
+        @echo -e '\t"scheduling": ['
+        @echo -en '\t\t'
+        @+make signal-cfa1.runquiet
+        @echo -en '\t\t,'
+        @+make signal-cfa2.runquiet
+        @echo -en '\t\t,'
+        @+make waitfor-cfa1.runquiet
+        @echo -en '\t\t,'
+        @+make waitfor-cfa2.runquiet
+        @echo -e '\n\t],'
+        @echo -e '\t"epoch": ' $(shell date +%s)
+        @echo "}"
 loop$(EXEEXT):
         $(BENCH_V_CC)$(COMPILE) -DBENCH_N=5000000000 $(srcdir)/loop.c
+        $(AM_V_CC)$(COMPILE) -DBENCH_N=5000000000 $(srcdir)/loop.c
 function$(EXEEXT):
         $(BENCH_V_CC)$(COMPILE) -DBENCH_N=5000000000 $(srcdir)/function.c
+        $(AM_V_CC)$(COMPILE) -DBENCH_N=5000000000 $(srcdir)/function.c
 fetch_add$(EXEEXT):
+        $(BENCH_V_CC)$(COMPILE) -DBENCH_N=500000000  $(srcdir)/fetch_add.c
+tls-fetch_add$(EXEEXT):
+        $(BENCH_V_CC)$(COMPILE) -DBENCH_N=500000000  $(srcdir)/tls-fetch_add.c
+        $(AM_V_CC)$(COMPILE) -DBENCH_N=500000000  $(srcdir)/fetch_add.c
 @WITH_LIBFIBRE_TRUE@ctxswitch-kos_fibre$(EXEEXT):
 @WITH_LIBFIBRE_TRUE@    $(BENCH_V_CXX)$(CXXCOMPILE) -DBENCH_N=50000000 $(srcdir)/ctxswitch/kos_fibre.cpp  -I$(LIBFIBRE_DIR) -lfibre
+@WITH_LIBFIBRE_TRUE@    $(AM_V_CXX)$(CXXCOMPILE) -DBENCH_N=50000000 $(srcdir)/ctxswitch/kos_fibre.cpp  -I$(LIBFIBRE_DIR) -lfibre
 @WITH_LIBFIBRE_TRUE@ctxswitch-kos_fibre2$(EXEEXT):
 @WITH_LIBFIBRE_TRUE@    $(BENCH_V_CXX)$(CXXCOMPILE) -DBENCH_N=50000000 $(srcdir)/ctxswitch/kos_fibre2.cpp -I$(LIBFIBRE_DIR) -lfibre
+@WITH_LIBFIBRE_TRUE@    $(AM_V_CXX)$(CXXCOMPILE) -DBENCH_N=50000000 $(srcdir)/ctxswitch/kos_fibre2.cpp -I$(LIBFIBRE_DIR) -lfibre
 ctxswitch$(EXEEXT): $(CTXSWITCH_DEPEND)
 ctxswitch-pthread$(EXEEXT):
         $(BENCH_V_CC)$(COMPILE)    -DBENCH_N=50000000 $(srcdir)/ctxswitch/pthreads.c
+        $(AM_V_CC)$(COMPILE)    -DBENCH_N=50000000 $(srcdir)/ctxswitch/pthreads.c
 ctxswitch-cfa_coroutine$(EXEEXT):
         $(BENCH_V_CFA)$(CFACOMPILE) -DBENCH_N=50000000 $(srcdir)/ctxswitch/cfa_cor.cfa
+        $(AM_V_CFA)$(CFACOMPILE) -DBENCH_N=50000000 $(srcdir)/ctxswitch/cfa_cor.cfa
 ctxswitch-cfa_thread$(EXEEXT):
         $(BENCH_V_CFA)$(CFACOMPILE) -DBENCH_N=50000000 $(srcdir)/ctxswitch/cfa_thrd.cfa
+        $(AM_V_CFA)$(CFACOMPILE) -DBENCH_N=50000000 $(srcdir)/ctxswitch/cfa_thrd.cfa
 ctxswitch-cfa_thread2$(EXEEXT):
         $(BENCH_V_CFA)$(CFACOMPILE) -DBENCH_N=50000000 $(srcdir)/ctxswitch/cfa_thrd2.cfa
+        $(AM_V_CFA)$(CFACOMPILE) -DBENCH_N=50000000 $(srcdir)/ctxswitch/cfa_thrd2.cfa
 ctxswitch-upp_coroutine$(EXEEXT):
         $(BENCH_V_UPP)$(UPPCOMPILE) -DBENCH_N=50000000 $(srcdir)/ctxswitch/upp_cor.cc
+        $(AM_V_UPP)$(UPPCOMPILE) -DBENCH_N=50000000 $(srcdir)/ctxswitch/upp_cor.cc
 ctxswitch-upp_thread$(EXEEXT):
         $(BENCH_V_UPP)$(UPPCOMPILE) -DBENCH_N=50000000 $(srcdir)/ctxswitch/upp_thrd.cc
+        $(AM_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
+        $(AM_V_GOC)go build -o a.out $(srcdir)/ctxswitch/goroutine.go
 ctxswitch-java_thread$(EXEEXT):
         $(BENCH_V_JAVAC)javac -d $(builddir) $(srcdir)/ctxswitch/JavaThread.java
+        $(AM_V_JAVAC)javac -d $(builddir) $(srcdir)/ctxswitch/JavaThread.java
         @echo "#!/bin/sh" > a.out
         @echo "java JavaThread" >> a.out
 …
 mutex-pthread_lock$(EXEEXT):
         $(BENCH_V_CC)$(COMPILE)    -DBENCH_N=50000000 $(srcdir)/mutex/pthreads.c
+        $(AM_V_CC)$(COMPILE)    -DBENCH_N=50000000 $(srcdir)/mutex/pthreads.c
 mutex-upp$(EXEEXT):
         $(BENCH_V_UPP)$(UPPCOMPILE) -DBENCH_N=50000000 $(srcdir)/mutex/upp.cc
+        $(AM_V_UPP)$(UPPCOMPILE) -DBENCH_N=50000000 $(srcdir)/mutex/upp.cc
 mutex-cfa1$(EXEEXT):
         $(BENCH_V_CFA)$(CFACOMPILE) -DBENCH_N=5000000  $(srcdir)/mutex/cfa1.cfa
+        $(AM_V_CFA)$(CFACOMPILE) -DBENCH_N=5000000  $(srcdir)/mutex/cfa1.cfa
 mutex-cfa2$(EXEEXT):
         $(BENCH_V_CFA)$(CFACOMPILE) -DBENCH_N=5000000  $(srcdir)/mutex/cfa2.cfa
+        $(AM_V_CFA)$(CFACOMPILE) -DBENCH_N=5000000  $(srcdir)/mutex/cfa2.cfa
 mutex-cfa4$(EXEEXT):
         $(BENCH_V_CFA)$(CFACOMPILE) -DBENCH_N=5000000  $(srcdir)/mutex/cfa4.cfa
+        $(AM_V_CFA)$(CFACOMPILE) -DBENCH_N=5000000  $(srcdir)/mutex/cfa4.cfa
 mutex-java_thread$(EXEEXT):
         $(BENCH_V_JAVAC)javac -d $(builddir) $(srcdir)/mutex/JavaThread.java
+        $(AM_V_JAVAC)javac -d $(builddir) $(srcdir)/mutex/JavaThread.java
         @echo "#!/bin/sh" > a.out
         @echo "java JavaThread" >> a.out
 …
 signal-pthread_cond$(EXEEXT):
         $(BENCH_V_CC)$(COMPILE)    -DBENCH_N=500000  $(srcdir)/schedint/pthreads.c
+        $(AM_V_CC)$(COMPILE)    -DBENCH_N=500000  $(srcdir)/schedint/pthreads.c
 signal-upp$(EXEEXT):
         $(BENCH_V_UPP)$(UPPCOMPILE) -DBENCH_N=5000000 $(srcdir)/schedint/upp.cc
+        $(AM_V_UPP)$(UPPCOMPILE) -DBENCH_N=5000000 $(srcdir)/schedint/upp.cc
 signal-cfa1$(EXEEXT):
         $(BENCH_V_CFA)$(CFACOMPILE) -DBENCH_N=500000  $(srcdir)/schedint/cfa1.cfa
+        $(AM_V_CFA)$(CFACOMPILE) -DBENCH_N=500000  $(srcdir)/schedint/cfa1.cfa
 signal-cfa2$(EXEEXT):
         $(BENCH_V_CFA)$(CFACOMPILE) -DBENCH_N=500000  $(srcdir)/schedint/cfa2.cfa
+        $(AM_V_CFA)$(CFACOMPILE) -DBENCH_N=500000  $(srcdir)/schedint/cfa2.cfa
 signal-cfa4$(EXEEXT):
         $(BENCH_V_CFA)$(CFACOMPILE) -DBENCH_N=500000  $(srcdir)/schedint/cfa4.cfa
+        $(AM_V_CFA)$(CFACOMPILE) -DBENCH_N=500000  $(srcdir)/schedint/cfa4.cfa
 signal-java_thread$(EXEEXT):
         $(BENCH_V_JAVAC)javac -d $(builddir) $(srcdir)/schedint/JavaThread.java
+        $(AM_V_JAVAC)javac -d $(builddir) $(srcdir)/schedint/JavaThread.java
         @echo "#!/bin/sh" > a.out
         @echo "java JavaThread" >> a.out
 …
 waitfor-upp$(EXEEXT):
         $(BENCH_V_UPP)$(UPPCOMPILE) -DBENCH_N=5000000 $(srcdir)/schedext/upp.cc
+        $(AM_V_UPP)$(UPPCOMPILE) -DBENCH_N=5000000 $(srcdir)/schedext/upp.cc
 waitfor-cfa1$(EXEEXT):
         $(BENCH_V_CFA)$(CFACOMPILE) -DBENCH_N=500000  $(srcdir)/schedext/cfa1.cfa
+        $(AM_V_CFA)$(CFACOMPILE) -DBENCH_N=500000  $(srcdir)/schedext/cfa1.cfa
 waitfor-cfa2$(EXEEXT):
         $(BENCH_V_CFA)$(CFACOMPILE) -DBENCH_N=500000  $(srcdir)/schedext/cfa2.cfa
+        $(AM_V_CFA)$(CFACOMPILE) -DBENCH_N=500000  $(srcdir)/schedext/cfa2.cfa
 waitfor-cfa4$(EXEEXT):
         $(BENCH_V_CFA)$(CFACOMPILE) -DBENCH_N=500000  $(srcdir)/schedext/cfa4.cfa
+        $(AM_V_CFA)$(CFACOMPILE) -DBENCH_N=500000  $(srcdir)/schedext/cfa4.cfa
 creation$(EXEEXT) :\
 …
 creation-cfa_coroutine$(EXEEXT):
         $(BENCH_V_CFA)$(CFACOMPILE) -DBENCH_N=10000000 $(srcdir)/creation/cfa_cor.cfa
+        $(AM_V_CFA)$(CFACOMPILE) -DBENCH_N=10000000 $(srcdir)/creation/cfa_cor.cfa
 creation-cfa_coroutine_eager$(EXEEXT):
         $(BENCH_V_CFA)$(CFACOMPILE) -DBENCH_N=10000000 $(srcdir)/creation/cfa_cor.cfa  -DEAGER
+        $(AM_V_CFA)$(CFACOMPILE) -DBENCH_N=10000000 $(srcdir)/creation/cfa_cor.cfa  -DEAGER
 creation-cfa_thread$(EXEEXT):
         $(BENCH_V_CFA)$(CFACOMPILE) -DBENCH_N=10000000 $(srcdir)/creation/cfa_thrd.cfa
+        $(AM_V_CFA)$(CFACOMPILE) -DBENCH_N=10000000 $(srcdir)/creation/cfa_thrd.cfa
 creation-upp_coroutine$(EXEEXT):
         $(BENCH_V_UPP)$(UPPCOMPILE) -DBENCH_N=50000000 $(srcdir)/creation/upp_cor.cc
+        $(AM_V_UPP)$(UPPCOMPILE) -DBENCH_N=50000000 $(srcdir)/creation/upp_cor.cc
 creation-upp_thread$(EXEEXT):
         $(BENCH_V_UPP)$(UPPCOMPILE) -DBENCH_N=50000000 $(srcdir)/creation/upp_thrd.cc
+        $(AM_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
+        $(AM_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
+        $(AM_V_GOC)go build -o a.out $(srcdir)/creation/goroutine.go
 creation-java_thread$(EXEEXT):
         $(BENCH_V_JAVAC)javac -d $(builddir) $(srcdir)/creation/JavaThread.java
+        $(AM_V_JAVAC)javac -d $(builddir) $(srcdir)/creation/JavaThread.java
         @echo "#!/bin/sh" > a.out
         @echo "java JavaThread" >> a.out
 …
 compile-array$(EXEEXT):
         @$(CFACOMPILE) -fsyntax-only -w $(testdir)/array.cfa
+        $(AM_V_CFA)$(CFACOMPILE) -fsyntax-only -w $(testdir)/array.cfa
 compile-attributes$(EXEEXT):
         @$(CFACOMPILE) -fsyntax-only -w $(testdir)/attributes.cfa
+        $(AM_V_CFA)$(CFACOMPILE) -fsyntax-only -w $(testdir)/attributes.cfa
 compile-empty$(EXEEXT):
         @$(CFACOMPILE) -fsyntax-only -w $(srcdir)/compile/empty.cfa
+        $(AM_V_CFA)$(CFACOMPILE) -fsyntax-only -w $(srcdir)/compile/empty.cfa
 compile-expression$(EXEEXT):
         @$(CFACOMPILE) -fsyntax-only -w $(testdir)/expression.cfa
+        $(AM_V_CFA)$(CFACOMPILE) -fsyntax-only -w $(testdir)/expression.cfa
 compile-io$(EXEEXT):
         @$(CFACOMPILE) -fsyntax-only -w $(testdir)/io1.cfa
+        $(AM_V_CFA)$(CFACOMPILE) -fsyntax-only -w $(testdir)/io1.cfa
 compile-monitor$(EXEEXT):
         @$(CFACOMPILE) -fsyntax-only -w $(testdir)/concurrent/monitor.cfa
+        $(AM_V_CFA)$(CFACOMPILE) -fsyntax-only -w $(testdir)/concurrent/monitor.cfa
 compile-operators$(EXEEXT):
         @$(CFACOMPILE) -fsyntax-only -w $(testdir)/operators.cfa
+        $(AM_V_CFA)$(CFACOMPILE) -fsyntax-only -w $(testdir)/operators.cfa
 compile-thread$(EXEEXT):
         @$(CFACOMPILE) -fsyntax-only -w $(testdir)/concurrent/thread.cfa
+        $(AM_V_CFA)$(CFACOMPILE) -fsyntax-only -w $(testdir)/concurrent/thread.cfa
 compile-typeof$(EXEEXT):
         @$(CFACOMPILE) -fsyntax-only -w $(testdir)/typeof.cfa
+        $(AM_V_CFA)$(CFACOMPILE) -fsyntax-only -w $(testdir)/typeof.cfa
 # Tell versions [3.59,3.63) of GNU make to not export all variables.

benchmark/ctxswitch/cfa_cor.cfa

r933f32f	r6a9d4b4
11	11	}
12	12
13		void main( ~~__attribute__((unused))~~ GreatSuspender & this ) {
	13	void main( GreatSuspender & this ) {
14	14	while( true ) {
15	15	suspend();

benchmark/ctxswitch/cfa_thrd2.cfa

r933f32f	r6a9d4b4
8	8	thread Fibre {};
9	9
10		void main(~~__attribute__((unused))~~ Fibre & this) {
	10	void main(Fibre & this) {
11	11	while(!done) {
12	12	yield();

configure

-              r933f32f
+              r6a9d4b4
 LIBOBJS
 CFA_BACKEND_CC
+WITH_LIBTCMALLOC_FALSE
+WITH_LIBTCMALLOC_TRUE
+WITH_LIBPROFILER_FALSE
+WITH_LIBPROFILER_TRUE
+ALLOCA
 WITH_LIBFIBRE_FALSE
 WITH_LIBFIBRE_TRUE
 …
 } # ac_fn_cxx_try_link
+# ac_fn_c_check_type LINENO TYPE VAR INCLUDES
+# -------------------------------------------
+# Tests whether TYPE exists after having included INCLUDES, setting cache
+# variable VAR accordingly.
+ac_fn_c_check_type ()
+{
+  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
+  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
+$as_echo_n "checking for $2... " >&6; }
+if eval \${$3+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  eval "$3=no"
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+$4
+int
+main ()
+{
+if (sizeof ($2))
+         return 0;
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"; then :
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+$4
+int
+main ()
+{
+if (sizeof (($2)))
+            return 0;
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"; then :
+else
+  eval "$3=yes"
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+fi
+eval ac_res=\$$3
+               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
+$as_echo "$ac_res" >&6; }
+  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
+} # ac_fn_c_check_type
 # ac_fn_c_check_header_mongrel LINENO HEADER VAR INCLUDES
 # -------------------------------------------------------
 …
 } # ac_fn_c_check_header_mongrel
 # ac_fn_c_check_type LINENO TYPE VAR INCLUDES
 # -------------------------------------------
 # Tests whether TYPE exists after having included INCLUDES, setting cache
 # variable VAR accordingly.
 ac_fn_c_check_type ()
+# ac_fn_c_find_intX_t LINENO BITS VAR
+# -----------------------------------
+# Finds a signed integer type with width BITS, setting cache variable VAR
+# accordingly.
+ac_fn_c_find_intX_t ()
+{
   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
 $as_echo_n "checking for $2... " >&6; }
+  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for int$2_t" >&5
+$as_echo_n "checking for int$2_t... " >&6; }
 if eval \${$3+:} false; then :
   $as_echo_n "(cached) " >&6
 else
   eval "$3=no"
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+     # Order is important - never check a type that is potentially smaller
+     # than half of the expected target width.
+     for ac_type in int$2_t 'int' 'long int' \
+         'long long int' 'short int' 'signed char'; do
+       cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
+$4
+$ac_includes_default
+             enum { N = $2 / 2 - 1 };
 int
 main ()
+{
+if (sizeof ($2))
+         return 0;
+static int test_array [1 - 2 * !(0 < ($ac_type) ((((($ac_type) 1 << N) << N) - 1) * 2 + 1))];
+test_array [0] = 0;
+return test_array [0];
+  ;
   return 0;
 …
   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
+$4
+$ac_includes_default
+                enum { N = $2 / 2 - 1 };
 int
 main ()
+{
+if (sizeof (($2)))
+            return 0;
+static int test_array [1 - 2 * !(($ac_type) ((((($ac_type) 1 << N) << N) - 1) * 2 + 1)
+                 < ($ac_type) ((((($ac_type) 1 << N) << N) - 1) * 2 + 2))];
+test_array [0] = 0;
+return test_array [0];
+  ;
   return 0;
 …
 else
+  eval "$3=yes"
+  case $ac_type in #(
+  int$2_t) :
+    eval "$3=yes" ;; #(
+  *) :
+    eval "$3=\$ac_type" ;;
+esac
 fi
 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
 fi
 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+       if eval test \"x\$"$3"\" = x"no"; then :
+else
+  break
+fi
+     done
 fi
 eval ac_res=\$$3
 …
   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
+} # ac_fn_c_check_type
+} # ac_fn_c_find_intX_t
+# ac_fn_c_find_uintX_t LINENO BITS VAR
+# ------------------------------------
+# Finds an unsigned integer type with width BITS, setting cache variable VAR
+# accordingly.
+ac_fn_c_find_uintX_t ()
+{
+  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
+  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for uint$2_t" >&5
+$as_echo_n "checking for uint$2_t... " >&6; }
+if eval \${$3+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  eval "$3=no"
+     # Order is important - never check a type that is potentially smaller
+     # than half of the expected target width.
+     for ac_type in uint$2_t 'unsigned int' 'unsigned long int' \
+         'unsigned long long int' 'unsigned short int' 'unsigned char'; do
+       cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+$ac_includes_default
+int
+main ()
+{
+static int test_array [1 - 2 * !((($ac_type) -1 >> ($2 / 2 - 1)) >> ($2 / 2 - 1) == 3)];
+test_array [0] = 0;
+return test_array [0];
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"; then :
+  case $ac_type in #(
+  uint$2_t) :
+    eval "$3=yes" ;; #(
+  *) :
+    eval "$3=\$ac_type" ;;
+esac
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+       if eval test \"x\$"$3"\" = x"no"; then :
+else
+  break
+fi
+     done
+fi
+eval ac_res=\$$3
+               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
+$as_echo "$ac_res" >&6; }
+  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
+} # ac_fn_c_find_uintX_t
 cat >config.log <<_ACEOF
 This file contains any messages produced by compilers while
 …
-# http://git.savannah.gnu.org/gitweb/?p=autoconf-archive.git;a=blob_plain;f=m4/ax_check_compile_flag.m4
 # don't use the default CFLAGS as they unconditonnaly add -O2
 …
                 "debug") ;;
                 "nolib") ;;
-                "profile") ;;
                 *)
                         >&2 echo "Configuration must be 'debug', 'nodebug' or 'nolib'"
 …
+        # deprecated
 # These are often not installed and people miss seeing the "no", so stop the configure.
 for ac_prog in 'bison -y' byacc
 …
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether ${MAKE-make} sets \$(MAKE)" >&5
+$as_echo_n "checking whether ${MAKE-make} sets \$(MAKE)... " >&6; }
+set x ${MAKE-make}
+ac_make=`$as_echo "$2" | sed 's/+/p/g; s/[^a-zA-Z0-9_]/_/g'`
+if eval \${ac_cv_prog_make_${ac_make}_set+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  cat >conftest.make <<\_ACEOF
+SHELL = /bin/sh
+all:
+        @echo '@@@%%%=$(MAKE)=@@@%%%'
+_ACEOF
+# GNU make sometimes prints "make[1]: Entering ...", which would confuse us.
+case `${MAKE-make} -f conftest.make 2>/dev/null` in
+  *@@@%%%=?*=@@@%%%*)
+    eval ac_cv_prog_make_${ac_make}_set=yes;;
+  *)
+    eval ac_cv_prog_make_${ac_make}_set=no;;
+esac
+rm -f conftest.make
+fi
+if eval test \$ac_cv_prog_make_${ac_make}_set = yes; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+$as_echo "yes" >&6; }
+  SET_MAKE=
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+  SET_MAKE="MAKE=${MAKE-make}"
+fi
 # Checks for libraries.
 …
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for ProfilingIsEnabledForAllThreads in -lprofiler" >&5
+$as_echo_n "checking for ProfilingIsEnabledForAllThreads in -lprofiler... " >&6; }
+if ${ac_cv_lib_profiler_ProfilingIsEnabledForAllThreads+:} false; then :
+# Checks for header files.
+ac_fn_c_check_type "$LINENO" "size_t" "ac_cv_type_size_t" "$ac_includes_default"
+if test "x$ac_cv_type_size_t" = xyes; then :
+else
+cat >>confdefs.h <<_ACEOF
+#define size_t unsigned int
+_ACEOF
+fi
+# The Ultrix 4.2 mips builtin alloca declared by alloca.h only works
+# for constant arguments.  Useless!
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for working alloca.h" >&5
+$as_echo_n "checking for working alloca.h... " >&6; }
+if ${ac_cv_working_alloca_h+:} false; then :
   $as_echo_n "(cached) " >&6
 else
+  ac_check_lib_save_LIBS=$LIBS
+LIBS="-lprofiler  $LIBS"
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
+/* Override any GCC internal prototype to avoid an error.
+   Use char because int might match the return type of a GCC
+   builtin and then its argument prototype would still apply.  */
+#ifdef __cplusplus
+extern "C"
+#endif
+char ProfilingIsEnabledForAllThreads ();
+#include <alloca.h>
 int
 main ()
+{
+return ProfilingIsEnabledForAllThreads ();
+char *p = (char *) alloca (2 * sizeof (int));
+                          if (p) return 0;
+  ;
   return 0;
 …
 _ACEOF
 if ac_fn_c_try_link "$LINENO"; then :
   ac_cv_lib_profiler_ProfilingIsEnabledForAllThreads=yes
 else
   ac_cv_lib_profiler_ProfilingIsEnabledForAllThreads=no
+  ac_cv_working_alloca_h=yes
+else
+  ac_cv_working_alloca_h=no
 fi
 rm -f core conftest.err conftest.$ac_objext \
     conftest$ac_exeext conftest.$ac_ext
+LIBS=$ac_check_lib_save_LIBS
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_profiler_ProfilingIsEnabledForAllThreads" >&5
+$as_echo "$ac_cv_lib_profiler_ProfilingIsEnabledForAllThreads" >&6; }
+if test "x$ac_cv_lib_profiler_ProfilingIsEnabledForAllThreads" = xyes; then :
+  HAVE_LIBPROFILER=1
+else
+  HAVE_LIBPROFILER=0
+fi
+ if test "$HAVE_LIBPROFILER" -eq 1; then
+  WITH_LIBPROFILER_TRUE=
+  WITH_LIBPROFILER_FALSE='#'
+else
+  WITH_LIBPROFILER_TRUE='#'
+  WITH_LIBPROFILER_FALSE=
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for malloc in -ltcmalloc" >&5
+$as_echo_n "checking for malloc in -ltcmalloc... " >&6; }
+if ${ac_cv_lib_tcmalloc_malloc+:} false; then :
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_working_alloca_h" >&5
+$as_echo "$ac_cv_working_alloca_h" >&6; }
+if test $ac_cv_working_alloca_h = yes; then
+$as_echo "#define HAVE_ALLOCA_H 1" >>confdefs.h
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for alloca" >&5
+$as_echo_n "checking for alloca... " >&6; }
+if ${ac_cv_func_alloca_works+:} false; then :
   $as_echo_n "(cached) " >&6
 else
+  ac_check_lib_save_LIBS=$LIBS
+LIBS="-ltcmalloc  $LIBS"
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
+/* Override any GCC internal prototype to avoid an error.
+   Use char because int might match the return type of a GCC
+   builtin and then its argument prototype would still apply.  */
+#ifdef __cplusplus
+extern "C"
+#ifdef __GNUC__
+# define alloca __builtin_alloca
+#else
+# ifdef _MSC_VER
+#  include <malloc.h>
+#  define alloca _alloca
+# else
+#  ifdef HAVE_ALLOCA_H
+#   include <alloca.h>
+#  else
+#   ifdef _AIX
+ #pragma alloca
+#   else
+#    ifndef alloca /* predefined by HP cc +Olibcalls */
+void *alloca (size_t);
+#    endif
+#   endif
+#  endif
+# endif
 #endif
+char malloc ();
 int
 main ()
+{
+return malloc ();
+char *p = (char *) alloca (1);
+                                    if (p) return 0;
+  ;
   return 0;
 …
 _ACEOF
 if ac_fn_c_try_link "$LINENO"; then :
   ac_cv_lib_tcmalloc_malloc=yes
 else
   ac_cv_lib_tcmalloc_malloc=no
+  ac_cv_func_alloca_works=yes
+else
+  ac_cv_func_alloca_works=no
 fi
 rm -f core conftest.err conftest.$ac_objext \
     conftest$ac_exeext conftest.$ac_ext
+LIBS=$ac_check_lib_save_LIBS
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_tcmalloc_malloc" >&5
+$as_echo "$ac_cv_lib_tcmalloc_malloc" >&6; }
+if test "x$ac_cv_lib_tcmalloc_malloc" = xyes; then :
+  HAVE_LIBTCMALLOC=1
+else
+  HAVE_LIBTCMALLOC=0
+fi
+ if test "$HAVE_LIBTCMALLOC" -eq 1; then
+  WITH_LIBTCMALLOC_TRUE=
+  WITH_LIBTCMALLOC_FALSE='#'
+else
+  WITH_LIBTCMALLOC_TRUE='#'
+  WITH_LIBTCMALLOC_FALSE=
+fi
+# Checks for header files.
+for ac_header in libintl.h malloc.h unistd.h
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_func_alloca_works" >&5
+$as_echo "$ac_cv_func_alloca_works" >&6; }
+if test $ac_cv_func_alloca_works = yes; then
+$as_echo "#define HAVE_ALLOCA 1" >>confdefs.h
+else
+  # The SVR3 libPW and SVR4 libucb both contain incompatible functions
+# that cause trouble.  Some versions do not even contain alloca or
+# contain a buggy version.  If you still want to use their alloca,
+# use ar to extract alloca.o from them instead of compiling alloca.c.
+ALLOCA=\${LIBOBJDIR}alloca.$ac_objext
+$as_echo "#define C_ALLOCA 1" >>confdefs.h
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether \`alloca.c' needs Cray hooks" >&5
+$as_echo_n "checking whether \`alloca.c' needs Cray hooks... " >&6; }
+if ${ac_cv_os_cray+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#if defined CRAY && ! defined CRAY2
+webecray
+#else
+wenotbecray
+#endif
+_ACEOF
+if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
+  $EGREP "webecray" >/dev/null 2>&1; then :
+  ac_cv_os_cray=yes
+else
+  ac_cv_os_cray=no
+fi
+rm -f conftest*
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_os_cray" >&5
+$as_echo "$ac_cv_os_cray" >&6; }
+if test $ac_cv_os_cray = yes; then
+  for ac_func in _getb67 GETB67 getb67; do
+    as_ac_var=`$as_echo "ac_cv_func_$ac_func" | $as_tr_sh`
+ac_fn_c_check_func "$LINENO" "$ac_func" "$as_ac_var"
+if eval test \"x\$"$as_ac_var"\" = x"yes"; then :
+cat >>confdefs.h <<_ACEOF
+#define CRAY_STACKSEG_END $ac_func
+_ACEOF
+    break
+fi
+  done
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking stack direction for C alloca" >&5
+$as_echo_n "checking stack direction for C alloca... " >&6; }
+if ${ac_cv_c_stack_direction+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test "$cross_compiling" = yes; then :
+  ac_cv_c_stack_direction=0
+else
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+$ac_includes_default
+int
+find_stack_direction (int *addr, int depth)
+{
+  int dir, dummy = 0;
+  if (! addr)
+    addr = &dummy;
+  *addr = addr < &dummy ? 1 : addr == &dummy ? 0 : -1;
+  dir = depth ? find_stack_direction (addr, depth - 1) : 0;
+  return dir + dummy;
+}
+int
+main (int argc, char **argv)
+{
+  return find_stack_direction (0, argc + !argv + 20) < 0;
+}
+_ACEOF
+if ac_fn_c_try_run "$LINENO"; then :
+  ac_cv_c_stack_direction=1
+else
+  ac_cv_c_stack_direction=-1
+fi
+rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
+  conftest.$ac_objext conftest.beam conftest.$ac_ext
+fi
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_stack_direction" >&5
+$as_echo "$ac_cv_c_stack_direction" >&6; }
+cat >>confdefs.h <<_ACEOF
+#define STACK_DIRECTION $ac_cv_c_stack_direction
+_ACEOF
+fi
+for ac_header in fenv.h float.h inttypes.h libintl.h limits.h malloc.h stddef.h stdlib.h string.h unistd.h
 do :
   as_ac_Header=`$as_echo "ac_cv_header_$ac_header" | $as_tr_sh`
 …
 _ACEOF
-else
-  echo "Error: Missing required header"; exit 1
 fi
 …
 # Checks for typedefs, structures, and compiler characteristics.
+ac_fn_c_check_type "$LINENO" "_Float32" "ac_cv_type__Float32" "
+"
+if test "x$ac_cv_type__Float32" = xyes; then :
+cat >>confdefs.h <<_ACEOF
+#define HAVE__FLOAT32 1
+_ACEOF
+$as_echo "#define HAVE_KEYWORDS_FLOATXX /**/" >>confdefs.h
+fi
+# Checks for compiler flags.
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts -Wcast-function-type" >&5
+$as_echo_n "checking whether C compiler accepts -Wcast-function-type... " >&6; }
+if ${m4cfa_cv_check_cflags___Wcast_function_type+:} false; then :
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for stdbool.h that conforms to C99" >&5
+$as_echo_n "checking for stdbool.h that conforms to C99... " >&6; }
+if ${ac_cv_header_stdbool_h+:} false; then :
   $as_echo_n "(cached) " >&6
 else
+        m4cfa_check_save_flags=$CFLAGS
+        CFLAGS="$CFLAGS  -Wcast-function-type"
+        cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
+             #include <stdbool.h>
+             #ifndef bool
+              "error: bool is not defined"
+             #endif
+             #ifndef false
+              "error: false is not defined"
+             #endif
+             #if false
+              "error: false is not 0"
+             #endif
+             #ifndef true
+              "error: true is not defined"
+             #endif
+             #if true != 1
+              "error: true is not 1"
+             #endif
+             #ifndef __bool_true_false_are_defined
+              "error: __bool_true_false_are_defined is not defined"
+             #endif
+             struct s { _Bool s: 1; _Bool t; } s;
+             char a[true == 1 ? 1 : -1];
+             char b[false == 0 ? 1 : -1];
+             char c[__bool_true_false_are_defined == 1 ? 1 : -1];
+             char d[(bool) 0.5 == true ? 1 : -1];
+             /* See body of main program for 'e'.  */
+             char f[(_Bool) 0.0 == false ? 1 : -1];
+             char g[true];
+             char h[sizeof (_Bool)];
+             char i[sizeof s.t];
+             enum { j = false, k = true, l = false * true, m = true * 256 };
+             /* The following fails for
+                HP aC++/ANSI C B3910B A.05.55 [Dec 04 2003]. */
+             _Bool n[m];
+             char o[sizeof n == m * sizeof n[0] ? 1 : -1];
+             char p[-1 - (_Bool) 0 < 0 && -1 - (bool) 0 < 0 ? 1 : -1];
+             /* Catch a bug in an HP-UX C compiler.  See
+                http://gcc.gnu.org/ml/gcc-patches/2003-12/msg02303.html
+                http://lists.gnu.org/archive/html/bug-coreutils/2005-11/msg00161.html
+              */
+             _Bool q = true;
+             _Bool *pq = &q;
 int
 main ()
+{
+             bool e = &s;
+             *pq |= q;
+             *pq |= ! q;
+             /* Refer to every declared value, to avoid compiler optimizations.  */
+             return (!a + !b + !c + !d + !e + !f + !g + !h + !i + !!j + !k + !!l
+                     + !m + !n + !o + !p + !q + !pq);
+  ;
 …
 _ACEOF
 if ac_fn_c_try_compile "$LINENO"; then :
   m4cfa_cv_check_cflags___Wcast_function_type=yes
 else
   m4cfa_cv_check_cflags___Wcast_function_type=no
+  ac_cv_header_stdbool_h=yes
+else
+  ac_cv_header_stdbool_h=no
 fi
 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+        CFLAGS=$m4cfa_check_save_flags
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $m4cfa_cv_check_cflags___Wcast_function_type" >&5
+$as_echo "$m4cfa_cv_check_cflags___Wcast_function_type" >&6; }
+if test "x$m4cfa_cv_check_cflags___Wcast_function_type" = xyes; then :
+$as_echo "#define HAVE_CAST_FUNCTION_TYPE /**/" >>confdefs.h
+else
+  :
+fi
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_header_stdbool_h" >&5
+$as_echo "$ac_cv_header_stdbool_h" >&6; }
+   ac_fn_c_check_type "$LINENO" "_Bool" "ac_cv_type__Bool" "$ac_includes_default"
+if test "x$ac_cv_type__Bool" = xyes; then :
+cat >>confdefs.h <<_ACEOF
+#define HAVE__BOOL 1
+_ACEOF
+fi
+if test $ac_cv_header_stdbool_h = yes; then
+$as_echo "#define HAVE_STDBOOL_H 1" >>confdefs.h
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for inline" >&5
+$as_echo_n "checking for inline... " >&6; }
+if ${ac_cv_c_inline+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  ac_cv_c_inline=no
+for ac_kw in inline __inline__ __inline; do
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#ifndef __cplusplus
+typedef int foo_t;
+static $ac_kw foo_t static_foo () {return 0; }
+$ac_kw foo_t foo () {return 0; }
+#endif
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"; then :
+  ac_cv_c_inline=$ac_kw
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+  test "$ac_cv_c_inline" != no && break
+done
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_inline" >&5
+$as_echo "$ac_cv_c_inline" >&6; }
+case $ac_cv_c_inline in
+  inline | yes) ;;
+  *)
+    case $ac_cv_c_inline in
+      no) ac_val=;;
+      *) ac_val=$ac_cv_c_inline;;
+    esac
+    cat >>confdefs.h <<_ACEOF
+#ifndef __cplusplus
+#define inline $ac_val
+#endif
+_ACEOF
+    ;;
+esac
+ac_fn_c_find_intX_t "$LINENO" "16" "ac_cv_c_int16_t"
+case $ac_cv_c_int16_t in #(
+  no|yes) ;; #(
+  *)
+cat >>confdefs.h <<_ACEOF
+#define int16_t $ac_cv_c_int16_t
+_ACEOF
+;;
+esac
+ac_fn_c_find_intX_t "$LINENO" "32" "ac_cv_c_int32_t"
+case $ac_cv_c_int32_t in #(
+  no|yes) ;; #(
+  *)
+cat >>confdefs.h <<_ACEOF
+#define int32_t $ac_cv_c_int32_t
+_ACEOF
+;;
+esac
+ac_fn_c_find_intX_t "$LINENO" "8" "ac_cv_c_int8_t"
+case $ac_cv_c_int8_t in #(
+  no|yes) ;; #(
+  *)
+cat >>confdefs.h <<_ACEOF
+#define int8_t $ac_cv_c_int8_t
+_ACEOF
+;;
+esac
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for C/C++ restrict keyword" >&5
+$as_echo_n "checking for C/C++ restrict keyword... " >&6; }
+if ${ac_cv_c_restrict+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  ac_cv_c_restrict=no
+   # The order here caters to the fact that C++ does not require restrict.
+   for ac_kw in __restrict __restrict__ _Restrict restrict; do
+     cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+typedef int * int_ptr;
+        int foo (int_ptr $ac_kw ip) {
+        return ip[0];
+       }
+int
+main ()
+{
+int s[1];
+        int * $ac_kw t = s;
+        t[0] = 0;
+        return foo(t)
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"; then :
+  ac_cv_c_restrict=$ac_kw
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+     test "$ac_cv_c_restrict" != no && break
+   done
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_restrict" >&5
+$as_echo "$ac_cv_c_restrict" >&6; }
+ case $ac_cv_c_restrict in
+   restrict) ;;
+   no) $as_echo "#define restrict /**/" >>confdefs.h
+ ;;
+   *)  cat >>confdefs.h <<_ACEOF
+#define restrict $ac_cv_c_restrict
+_ACEOF
+ ;;
+ esac
+ac_fn_c_check_type "$LINENO" "size_t" "ac_cv_type_size_t" "$ac_includes_default"
+if test "x$ac_cv_type_size_t" = xyes; then :
+else
+cat >>confdefs.h <<_ACEOF
+#define size_t unsigned int
+_ACEOF
+fi
+ac_fn_c_find_uintX_t "$LINENO" "16" "ac_cv_c_uint16_t"
+case $ac_cv_c_uint16_t in #(
+  no|yes) ;; #(
+  *)
+cat >>confdefs.h <<_ACEOF
+#define uint16_t $ac_cv_c_uint16_t
+_ACEOF
+;;
+  esac
+ac_fn_c_find_uintX_t "$LINENO" "32" "ac_cv_c_uint32_t"
+case $ac_cv_c_uint32_t in #(
+  no|yes) ;; #(
+  *)
+$as_echo "#define _UINT32_T 1" >>confdefs.h
+cat >>confdefs.h <<_ACEOF
+#define uint32_t $ac_cv_c_uint32_t
+_ACEOF
+;;
+  esac
+ac_fn_c_find_uintX_t "$LINENO" "8" "ac_cv_c_uint8_t"
+case $ac_cv_c_uint8_t in #(
+  no|yes) ;; #(
+  *)
+$as_echo "#define _UINT8_T 1" >>confdefs.h
+cat >>confdefs.h <<_ACEOF
+#define uint8_t $ac_cv_c_uint8_t
+_ACEOF
+;;
+  esac
+# Checks for library functions.
+for ac_func in memset putenv strchr strtol
+do :
+  as_ac_var=`$as_echo "ac_cv_func_$ac_func" | $as_tr_sh`
+ac_fn_c_check_func "$LINENO" "$ac_func" "$as_ac_var"
+if eval test \"x\$"$as_ac_var"\" = x"yes"; then :
+  cat >>confdefs.h <<_ACEOF
+#define `$as_echo "HAVE_$ac_func" | $as_tr_cpp` 1
+_ACEOF
+fi
+done
 …
 #==============================================================================
 ac_config_files="$ac_config_files Makefile driver/Makefile src/Makefile benchmark/Makefile tests/Makefile longrun_tests/Makefile tools/Makefile tools/prettyprinter/Makefile"
+ac_config_files="$ac_config_files Makefile driver/Makefile src/Makefile benchmark/Makefile tests/Makefile tests/preempt_longrun/Makefile tools/Makefile tools/prettyprinter/Makefile"
 …
 if test -z "${WITH_LIBFIBRE_TRUE}" && test -z "${WITH_LIBFIBRE_FALSE}"; then
   as_fn_error $? "conditional \"WITH_LIBFIBRE\" was never defined.
-Usually this means the macro was only invoked conditionally." "$LINENO" 5
-fi
-if test -z "${WITH_LIBPROFILER_TRUE}" && test -z "${WITH_LIBPROFILER_FALSE}"; then
-  as_fn_error $? "conditional \"WITH_LIBPROFILER\" was never defined.
-Usually this means the macro was only invoked conditionally." "$LINENO" 5
-fi
-if test -z "${WITH_LIBTCMALLOC_TRUE}" && test -z "${WITH_LIBTCMALLOC_FALSE}"; then
-  as_fn_error $? "conditional \"WITH_LIBTCMALLOC\" was never defined.
 Usually this means the macro was only invoked conditionally." "$LINENO" 5
 fi
 …
     "benchmark/Makefile") CONFIG_FILES="$CONFIG_FILES benchmark/Makefile" ;;
     "tests/Makefile") CONFIG_FILES="$CONFIG_FILES tests/Makefile" ;;
     "longrun_tests/Makefile") CONFIG_FILES="$CONFIG_FILES longrun_tests/Makefile" ;;
+    "tests/preempt_longrun/Makefile") CONFIG_FILES="$CONFIG_FILES tests/preempt_longrun/Makefile" ;;
     "tools/Makefile") CONFIG_FILES="$CONFIG_FILES tools/Makefile" ;;
     "tools/prettyprinter/Makefile") CONFIG_FILES="$CONFIG_FILES tools/prettyprinter/Makefile" ;;

configure.ac

-              r933f32f
+              r6a9d4b4
                 "debug") ;;
                 "nolib") ;;
-                "profile") ;;
                 *)
                         >&2 echo "Configuration must be 'debug', 'nodebug' or 'nolib'"
 …
 AC_PROG_CC
 AM_PROG_AS
+AM_PROG_CC_C_O  # deprecated
 # These are often not installed and people miss seeing the "no", so stop the configure.
 AC_PROG_YACC
 …
 AC_PROG_LIBTOOL
 AC_PROG_INSTALL
+AC_PROG_MAKE_SET
 # Checks for libraries.
 …
 AM_CONDITIONAL([WITH_LIBFIBRE], [test "$HAVE_LIBFIBRE" -eq 1])
-AC_CHECK_LIB([profiler], [ProfilingIsEnabledForAllThreads], [HAVE_LIBPROFILER=1], [HAVE_LIBPROFILER=0])
-AM_CONDITIONAL([WITH_LIBPROFILER], [test "$HAVE_LIBPROFILER" -eq 1])
-AC_CHECK_LIB([tcmalloc], [malloc], [HAVE_LIBTCMALLOC=1], [HAVE_LIBTCMALLOC=0])
-AM_CONDITIONAL([WITH_LIBTCMALLOC], [test "$HAVE_LIBTCMALLOC" -eq 1])
 # Checks for header files.
+AC_CHECK_HEADERS([libintl.h malloc.h unistd.h], [], [echo "Error: Missing required header"; exit 1])
+AC_FUNC_ALLOCA
+AC_CHECK_HEADERS([fenv.h float.h inttypes.h libintl.h limits.h malloc.h stddef.h stdlib.h string.h unistd.h])
 # Checks for typedefs, structures, and compiler characteristics.
+AC_CHECK_TYPES([_Float32], AC_DEFINE([HAVE_KEYWORDS_FLOATXX], [], [Have keywords _FloatXX.]), [], [[]])
+# Checks for compiler flags.
+M4CFA_CHECK_COMPILE_FLAG([-Wcast-function-type], AC_DEFINE([HAVE_CAST_FUNCTION_TYPE], [], [Have compiler warning cast-function-type.]))
+AC_HEADER_STDBOOL
+AC_C_INLINE
+AC_TYPE_INT16_T
+AC_TYPE_INT32_T
+AC_TYPE_INT8_T
+AC_C_RESTRICT
+AC_TYPE_SIZE_T
+AC_TYPE_UINT16_T
+AC_TYPE_UINT32_T
+AC_TYPE_UINT8_T
+# Checks for library functions.
+AC_CHECK_FUNCS([memset putenv strchr strtol])
 #==============================================================================
 …
         benchmark/Makefile
         tests/Makefile
         longrun_tests/Makefile
+        tests/preempt_longrun/Makefile
         tools/Makefile
         tools/prettyprinter/Makefile

doc/LaTeXmacros/lstlang.sty

-              r933f32f
+              r6a9d4b4
 %% Created On       : Sat May 13 16:34:42 2017
 %% Last Modified By : Peter A. Buhr
 %% Last Modified On : Tue Jan  8 14:40:33 2019
 %% Update Count     : 21
+%% Last Modified On : Fri Apr  6 23:44:50 2018
+%% Update Count     : 20
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 …
                 _Alignas, _Alignof, __alignof, __alignof__, asm, __asm, __asm__, __attribute, __attribute__,
                 auto, _Bool, catch, catchResume, choose, _Complex, __complex, __complex__, __const, __const__,
                 coroutine, disable, dtype, enable, exception, __extension__, fallthrough, fallthru, finally,
+                coroutine, disable, dtype, enable, __extension__, exception, fallthrough, fallthru, finally,
                 __float80, float80, __float128, float128, forall, ftype, _Generic, _Imaginary, __imag, __imag__,
                 inline, __inline, __inline__, __int128, int128, __label__, monitor, mutex, _Noreturn, one_t, or,

doc/bibliography/pl.bib

-              r933f32f
+              r6a9d4b4
     contributer = {pabuhr@plg},
     author      = {Nissim Francez},
     title       = {Another Advantage of Keyword Notation for Parameter Communication with Subprograms},
+    title       = {Another Advantage of Key word Notation for Parameter Communication with Subprograms},
     journal     = cacm,
     volume      = 20,
 …
     year        = 2015,
     howpublished= {\href{http://www.boost.org/doc/libs/1_61_0/libs/coroutine/doc/html/index.html}
+                  {http://www.boost.org/\-doc/\-libs/1\_61\_0/\-libs/\-coroutine/\-doc/\-html/\-index.html}},
+}
+@misc{BoostThreads,
+    keywords    = {Boost Thread Library},
+    contributer = {pabuhr@plg},
+    author      = {Anthony Williams and Vicente J. Botet Escriba},
+    title       = {Boost Thread Library},
+    year        = 2015,
+    howpublished= {\href{https://www.boost.org/doc/libs/1_61_0/doc/html/thread.html}
+                  {https://\-www.boost.org/\-doc/\-libs/\-1\_61\_0/\-doc/\-html/\-thread.html}},
+                  {{http://www.boost.org/\-doc/\-libs/1\_61\_0/\-libs/\-coroutine/\-doc/\-html/\-index.html}}},
+    optnote     = {Accessed: 2016-09},
+}
 …
     author      = {{\textsf{C}{$\mathbf{\forall}$} Features}},
     howpublished= {\href{https://plg.uwaterloo.ca/~cforall/features}{https://\-plg.uwaterloo.ca/\-$\sim$cforall/\-features}},
+    optnote     = {Accessed: 2018-01-01},
+}
 …
     year        = 2018,
     howpublished= {\href{https://cforall.uwaterloo.ca/CFAStackEvaluation.zip}{https://cforall.uwaterloo.ca/\-CFAStackEvaluation.zip}},
+    optnote     = {[Accessed May 2018]},
+}
 …
     contributer = {pabuhr@plg},
     author      = {Aaron Moss and Robert Schluntz and Peter A. Buhr},
     title       = {\textsf{C}$\mathbf{\forall}$ : Adding Modern Programming Language Features to {C}},
+    title       = {\textsf{C}$\mathbf{\forall}$ : Adding Modern Programming Language Features to C},
     journal     = spe,
     volume      = 48,
 …
+}
-@techreport{Prokopec11,
-  keywords = {ctrie, concurrent map},
-  contributer = {a3moss@uwaterloo.ca},
-  title={Cache-aware lock-free concurrent hash tries},
-  author={Prokopec, Aleksandar and Bagwell, Phil and Odersky, Martin},
-  institution={EPFL},
-  year={2011}
+}
 @article{Buhr85,
     keywords    = {goto, multi-exit loop},
 …
     year        = 1998,
     note        = {{\small\textsf{ftp://\-plg.uwaterloo.ca/\-pub/\-Cforall/\-refrat.ps.gz}}},
+}
-@phdthesis{Norrish98,
-  title={C formalised in HOL},
-  author={Norrish, Michael},
-  year={1998},
-  school={University of Cambridge}
+}
-@inproceedings{Tarditi18,
-    keywords    = {Checked C},
-    contributer = {a3moss@uwaterloo.ca},
-    author      = {Tarditi, David and Elliott, Archibald Samuel and Ruef, Andrew and Hicks, Michael},
-    title       = {Checked C: Making C Safe by Extension},
-    booktitle   = {2018 IEEE Cybersecurity Development (SecDev)},
-    year        = {2018},
-    month       = {September},
-    pages       = {53-60},
-    publisher   = {IEEE},
-    url         = {https://www.microsoft.com/en-us/research/publication/checkedc-making-c-safe-by-extension/},
+}
-@misc{Clang,
-    keywords    = {clang},
-    contributer = {a3moss@uwaterloo.ca},
-    title       = {Clang: a {C} language family frontend for {LLVM}},
-    howpublished= {\href{https://clang.llvm.org/}{https://\-clang.llvm.org/}}
+}
 …
+}
-@inproceedings{Odersky01,
- keywords = {Scala},
- contributer = {a3moss@uwaterloo.ca},
- author = {Odersky, Martin and Zenger, Christoph and Zenger, Matthias},
- title = {Colored Local Type Inference},
- booktitle = {Proceedings of the 28th ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages},
- series = {POPL '01},
- year = {2001},
- isbn = {1-58113-336-7},
- location = {London, United Kingdom},
- pages = {41--53},
- numpages = {13},
- url = {http://doi.acm.org/10.1145/360204.360207},
- doi = {10.1145/360204.360207},
- acmid = {360207},
- publisher = {ACM},
- address = {New York, NY, USA},
+}
 @book{sml:commentary,
     author      = {Robin Milner and Mads Tofte},
 …
     journal     = sigplan,
     year        = 1986,
+    month       = oct,
+    volume      = 21,
+    number      = 10,
+    pages       = {19-28},
+    month       = oct, volume = 21, number = 10, pages = {19-28},
     note        = {Object Oriented Programming Workshop}
+}
 …
     title       = {concurrent-locking},
     howpublished= {\href{https://github.com/pabuhr/concurrent-locking}{https://\-github.com/\-pabuhr/\-concurrent-locking}},
+    optnote     = {[Accessed April 2017]},
+}
 …
+}
-@inproceedings{Prokopec12,
-  keywords={ctrie, hash trie, concurrent map},
-  contributer={a3moss@uwaterloo.ca},
-  title={Concurrent tries with efficient non-blocking snapshots},
-  author={Prokopec, Aleksandar and Bronson, Nathan Grasso and Bagwell, Phil and Odersky, Martin},
-  booktitle={ACM SIGPLAN Notices},
-  volume={47},
-  number={8},
-  pages={151--160},
-  year={2012},
-  organization={ACM}
+}
 @article{Buhr05a,
     keywords    = {concurrency, myths},
 …
     howpublished= {\href{https://www.airs.com/blog/archives/428}
                   {https://www.airs.com/\-blog/\-archives/\-428}},
+    optnote     = {Accessed: 2018-05},
+}
 …
     year        = 1965,
     note        = {Reprinted in \cite{Genuys68} pp. 43--112.}
+}
-@manual{C++20Coroutine19,
-    keywords    = {coroutine},
-    contributer = {pabuhr@plg},
-    title       = {Coroutines (C++20)},
-    organization= {cppreference.com},
-    month       = apr,
-    year        = 2019,
-    note        = {\href{https://en.cppreference.com/w/cpp/language/coroutines}{https://\-en.cppreference.com/\-w/\-cpp/\-language/\-coroutines}},
+}
 …
+}
-@article{Ritchie93,
-    keywords    = {C, history},
-    contributer = {pabuhr@plg},
-    author      = {Ritchie, Dennis M.},
-    title       = {The Development of the {C} Language},
-    journal     = sigplan,
-    volume      = 28,
-    number      = 3,
-    month       = mar,
-    year        = 1993,
-    pages       = {201--208},
-    url         = {http://doi.acm.org/10.1145/155360.155580},
-    publisher   = {ACM},
-    address     = {New York, NY, USA},
+}
 @article{design,
     keywords    = {Smalltalk, designing classes},
 …
     journal     = joop,
     year        = 1988,
+    volume      = 1,
+    number      = 2,
+    pages       = {22-35},
+    volume      = 1, number = 2, pages = {22-35},
     comment     = {
         Abstract classes represent standard protocols.  ``It is better to
 …
     year        = 1990,
     pages       = {315-323}
+}
-@misc{Dotty-github,
-    keywords = {dotty,scala},
-    contributer = {a3moss@uwaterloo.ca},
-    author = {Martin Odersky},
-    title = {Dotty},
-    howpublished = {\href{https://github.com/lampepfl/dotty}{https://\-github.com/\-lampepfl/\-dotty}},
-    note = {Acessed: 2019-02-22}
+}
 …
     pages       = {325-361},
+}
-@article{Tarjan75,
- keywords = {union-find},
- contributer = {a3moss@uwaterloo.ca},
- author = {Tarjan, Robert Endre},
- title = {Efficiency of a Good But Not Linear Set Union Algorithm},
- journal = {J. ACM},
- issue_date = {April 1975},
- volume = {22},
- number = {2},
- month = apr,
- year = {1975},
- issn = {0004-5411},
- pages = {215--225},
- numpages = {11},
- url = {http://doi.acm.org/10.1145/321879.321884},
- doi = {10.1145/321879.321884},
- acmid = {321884},
- publisher = {ACM},
- address = {New York, NY, USA},
+}
 @book{Eiffel,
 …
     year        = 2014,
     howpublished= {\href{https://gcc.gnu.org/onlinedocs/gcc-4.7.2/gcc/C-Extensions.html}{https://\-gcc.gnu.org/\-onlinedocs/\-gcc-4.7.2/\-gcc/\-C\-Extensions.html}},
+    optnote     = {Accessed: 2017-04-02},
+}
 …
+}
-@manual{WindowsFibers,
-    keywords    = {threads, fibers},
-    contributer = {pabuhr@plg},
-    author      = {Windows},
-    title       = {Fibers},
-    organization= {Microsoft, Windows Development Center},
-    address     = {\href{https://docs.microsoft.com/en-us/windows/desktop/ProcThread/fibers}{https://\-docs.microsoft.com/\-en-us/\-windows/\-desktop/\-ProcThread/\-fibers}},
-    year        = 2018,
+}
 @inproceedings{F-bound,
     keywords    = {},
 …
+}
-@manual{Folly,
-    keywords    = {Folly},
-    contributer = {pabuhr@plg},
-    author      = {Folly},
-    title       = {Facebook Open-source Library},
-    organization= {Facebook},
-    address     = {\href{https://github.com/facebook/folly}{https://\-github.com/\-facebook/\-folly}},
-    year        = 2018,
+}
-@article{Leroy09,
- keywords = {C formalization},
- contributer = {a3moss@uwaterloo.ca},
- author = {Leroy, Xavier},
- title = {Formal Verification of a Realistic Compiler},
- journal = {Commun. ACM},
- issue_date = {July 2009},
- volume = {52},
- number = {7},
- month = jul,
- year = {2009},
- issn = {0001-0782},
- pages = {107--115},
- numpages = {9},
- url = {http://doi.acm.org/10.1145/1538788.1538814},
- doi = {10.1145/1538788.1538814},
- acmid = {1538814},
- publisher = {ACM},
- address = {New York, NY, USA},
+}
 @manual{Fortran95,
     keywords    = {Fortran 95},
 …
     address     = {\href{https://www.iso.org/standard/50459.html}{https://\-www.iso.org/\-standard/\-50459.html}},
     year        = 2010,
+}
-@manual{Fortran18,
-    keywords    = {ISO/IEC Fortran 10},
-    contributer = {pabuhr@plg},
-    author      = {Fortran18},
-    title       = {Programming Languages -- {Fortran} Part 1:Base Language ISO/IEC 1539-1:2018},
-    edition     = {4rd},
-    publisher   = {International Standard Organization},
-    address     = {\href{https://www.iso.org/standard/72320.html}{https://\-www.iso.org/\-standard/\-72320.html}},
-    year        = 2018,
+}
 …
     year        = 2014,
     howpublished= {https://developer.gnome.org/gobject/stable/},
+    optnote     = {Accessed: 2017-04},
+}
 …
     year        = {1964},
     publisher   = {ACM}
+}
-@phdthesis{Barghi18,
-    keywords    = {concurrency, user threads, actors},
-    contributer = {pabuhr@plg},
-    author      = {Saman Barghi},
-    title       = {Improving the Performance of User-level Runtime Systems for Concurrent Applications},
-    school      = {School of Computer Science, University of Waterloo},
-    year        = 2018,
-    month       = sep,
-    optaddress  = {Waterloo, Ontario, Canada, N2L 3G1},
-    note        = {\href{https://uwspace.uwaterloo.ca/handle/10012/13935}{https://\-uwspace.uwaterloo.ca/\-handle/\-10012/\-13935}},
+}
-@article{Swift05,
-   contributer  = {pabuhr@plg},
-   author       = {Michael M. Swift and Brian N. Bershad and Henry M. Levy},
-   title        = {Improving the Reliability of Commodity Operating Systems},
-   journal      = tocs,
-   volume       = 23,
-   number       = 1,
-   month        = feb,
-   year         = 2005,
-   pages        = {77-110},
+}
 …
+}
-@article{Morgado13,
-  keywords = {expression resolution},
-  contributer = {a3moss@uwaterloo.ca},
-  title={Iterative and core-guided {MaxSAT} solving: A survey and assessment},
-  author={Morgado, Antonio and Heras, Federico and Liffiton, Mark and Planes, Jordi and Marques-Silva, Joao},
-  journal={Constraints},
-  volume={18},
-  number={4},
-  pages={478--534},
-  year={2013},
-  publisher={Springer}
+}
 % J
 …
     year        = 2015,
     edition     = {{J}ava {SE} 8},
+}
-@manual{Java11,
-    keywords    = {Java SE 11},
-    contributer = {pabuhr@plg},
-    author      = {James Gosling and Bill Joy and Guy Steele and Gilad Bracha and Alex Buckley and Daniel Smith},
-    title       = {{Java} Language Specification},
-    publisher   = {Oracle},
-    month       = sep,
-    year        = 2018,
-    edition     = {{J}ava {SE} 11},
+}
-@manual{JDK1.1,
-    keywords    = {JDK 1.1},
-    contributer = {pabuhr@plg},
-    author      = {{Multithreading Models}},
-    title       = {JDK 1.1 for Solaris Developer's Guide},
-    publisher   = {Oracle},
-    address     = {\href{https://docs.oracle.com/cd/E19455-01/806-3461/6jck06gqk/index.html#ch2mt-41}{https://\-docs.oracle.com/\-cd/\-E19455-01/\-806-3461/\-6jck06gqk/\-index.html\#ch2mt-41}},
-    year        = 2010,
+}
 …
+}
-@manual{libmill,
-    keywords    = {libmill},
-    contributer = {pabuhr@plg},
-    author      = {libmill},
-    title       = {{G}o-style concurrency in {C}, Version 1.18},
-    organization= {libmill},
-    address     = {\href{http://libmill.org/documentation.html}{http://\-libmill.org/\-documentation.html}},
-    month       = jan,
-    year        = 2017,
+}
 @book{Weissman67,
     keywords    = {lisp},
 …
+}
-@article{Pierce00,
- keywords = {Scala},
- contributer = {a3moss@uwaterloo.ca},
- author = {Pierce, Benjamin C. and Turner, David N.},
- title = {Local Type Inference},
- journal = {ACM Trans. Program. Lang. Syst.},
- issue_date = {Jan. 2000},
- volume = {22},
- number = {1},
- month = jan,
- year = {2000},
- issn = {0164-0925},
- pages = {1--44},
- numpages = {44},
- url = {http://doi.acm.org/10.1145/345099.345100},
- doi = {10.1145/345099.345100},
- acmid = {345100},
- publisher = {ACM},
- address = {New York, NY, USA},
- keywords = {polymorphism, subtyping, type inference},
+}
 @article{Sundell08,
     keywords    = {lock free, deque},
 …
     year        = 2008,
     pages       = {1008-1020},
+}
-@misc{Matsakis17,
-    keywords    = {Rust, Chalk, PROLOG},
-    contributer = {a3moss@uwaterloo.ca},
-    author      = {Nicholas Matsakis},
-    title       = {Lowering {Rust} traits to logic},
-    month       = jan,
-    year        = 2017,
-    howpublished= {\href{http://smallcultfollowing.com/babysteps/blog/2017/01/26/lowering-rust-traits-to-logic/}
-                  {http://smallcultfollowing.com/\-babysteps/\-blog/\-2017/\-01/\-26/\-lowering-rust-traits-to-logic/}},
-    optnote     = {Accessed: 2019-01},
+}
 …
+}
-@manual{Lua,
-    keywords    = {Lua},
-    contributer = {pabuhr@plg},
-    author      = {Lua},
-    title       = {Lua 5.3 Reference Manual},
-    address     = {\href{https://www.lua.org/manual/5.3}{https://\-www.lua.org/\-manual/\-5.3}},
-    year        = 2018,
+}
 % M
 …
     publisher   = {Motorola},
     year        = 1992,
+}
-@misc{Haberman16,
-    keywords    = {C++ template expansion},
-    contributer = {a3moss@uwaterloo.ca},
-    author      = {Josh Haberman},
-    title       = {Making arbitrarily-large binaries from fixed-size {C}{\kern-.1em\hbox{\large\texttt{+\kern-.25em+}}} code},
-    year        = 2016,
-    howpublished= {\href{http://blog.reverberate.org/2016/01/making-arbitrarily-large-binaries-from.html}
+                  {
-          {http://blog.reverberate.org/\-2016/\-01/\-making-arbitrarily-large-binaries-from.html}
-          }},
-    optnote     = {Accessed: 2016-09},
+}
 …
+}
 %    editor     = {Allen Kent and James G. Williams},
-@incollection{MPC,
-    keywords    = {user-level threading},
-    contributer = {pabuhr@plg},
-    author      = {Marc P\'erache and Herv\'e Jourdren and Raymond Namyst},
-    title       = {MPC: A Unified Parallel Runtime for Clusters of {NUMA} Machines},
-    booktitle   = {Euro-Par 2008},
-    pages       = {329-342},
-    publisher   = {Springer},
-    address     = {Berlin, Heidelberg},
-    year        = 2008,
-    volume      = 5168,
-    series      = {Lecture Notes in Computer Science},
+}
 @manual{MPI,
 …
     year        = 2014,
     howpublished= {\href{https://developer.apple.com/library/archive/documentation/Cocoa/Conceptual/ProgrammingWithObjectiveC}{https://\-developer.apple.com/\-library/archive/\-documentation/\-Cocoa/\-Conceptual/\-ProgrammingWithObjectiveC}},
+    optnote     = {Accessed: 2018-03}
+}
 …
     year        = 2015,
     howpublished= {\href{https://developer.apple.com/library/content/documentation/Xcode/Conceptual/RN-Xcode-Archive/Chapters/xc7_release_notes.html}{https://\-developer.apple.com/\-library/\-content/\-documentation/\-Xcode/\-Conceptual/\-RN-Xcode-Archive/\-Chapters/\-xc7\_release\_notes.html}},
+    optnote     = {Accessed: 2017-04}
+}
 …
     note        = {\href{https://www.openmp.org/wp-content/uploads/openmp-4.5.pdf}{https://\-www.openmp.org/\-wp-content/\-uploads/\-openmp-4.5.pdf}},
+}
-@inproceedings{Krebbers14,
- keywords = {c formalization},
- contributer = {a3moss@uwaterloo.ca},
- author = {Krebbers, Robbert},
- title = {An Operational and Axiomatic Semantics for Non-determinism and Sequence Points in C},
- booktitle = {Proceedings of the 41st ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages},
- series = {POPL '14},
- year = {2014},
- isbn = {978-1-4503-2544-8},
- location = {San Diego, California, USA},
- pages = {101--112},
- numpages = {12},
- url = {http://doi.acm.org/10.1145/2535838.2535878},
- doi = {10.1145/2535838.2535878},
- acmid = {2535878},
- publisher = {ACM},
- address = {New York, NY, USA},
+}
 @book{Deitel04,
 …
     year        = 2012,
     howpublished= {\href{http://cs.brown.edu/research/pubs/theses/masters/2012/verch.pdf}{http://cs.brown.edu/\-research/\-pubs/\-theses/\-masters/\-2012/\-verch.pdf}},
+    optnote     = {Accessed: 2013-10-4}
+}
 …
     address     = {\href{https://www.iso.org/standard/64029.html}{https://\-www.iso.org/\-standard/\-64029.html}},
     year        = 2014,
+}
-@manual{C++17,
-    keywords    = {ISO/IEC C++ 17},
-    contributer = {pabuhr@plg},
-    key         = {C++17},
-    title       = {{C}{\kern-.1em\hbox{\large\texttt{+\kern-.25em+}}} Programming Language ISO/IEC 14882:2017},
-    edition     = {5th},
-    publisher   = {International Standard Organization},
-    address     = {\href{https://www.iso.org/standard/68564.html}{https://\-www.iso.org/\-standard/\-68564.html}},
-    year        = 2017,
+}
 …
     institution = {Carnegie Mellon University},
     year        = 1991,
+    month       = feb,
+    number      = {CMU-CS-91-106},
+    month       = feb, number = "CMU-CS-91-106",
     annote      = {
         Discusses a typed lambda calculus with
 …
     journal     = sigplan,
     year        = 1988,
+    month       = jul,
+    volume      = 23,
+    number      = 7,
+    pages       = {260-267},
+    note        = {Proceedings of the SIGPLAN '88 Conference on Programming Language Design and Implementation},
+    month       = jul, volume = 23, number = 7, pages = {260-267},
+    note        = {Proceedings of the SIGPLAN '88 Conference on Programming Language
+         Design and Implementation},
     abstract    = {
         This paper deals with the integration of an efficient asynchronous
 …
+}
-@misc{Pthreads,
-    keywords    = {pthreads, C concurrency},
-    contributer = {pabuhr@plg},
-    key         = {pthreads},
-    title       = {{Pthread}.h, Specifications Issue 7, {IEEE} Std 1003.1-2017},
-    author      = {IEEE and {The Open Group}},
-    year        = 2018,
-    howpublished= {\href{http://pubs.opengroup.org/onlinepubs/9699919799/basedefs/pthread.h.html}
-                  {http://\-pubs.opengroup.org/\-onlinepubs/\-9699919799/\-basedefs/\-pthread.h.html}},
+}
 @manual{Python,
     keywords    = {Python},
     contributer = {pabuhr@plg},
     author      = {Python},
     title       = {Python Language Reference, Release 3.7.2},
+    title       = {Python Reference Manual, Release 2.5},
+    author      = {Guido van Rossum},
     organization= {Python Software Foundation},
+    address     = {\href{https://docs.python.org/3/reference/index.html}{https://\-docs.python.org/\-3/\-reference/\-index.html}},
+    year        = 2018,
+    month       = sep,
+    year        = 2006,
+    note        = {Fred L. Drake, Jr., editor},
+}
 % Q
-@inproceedings{Qthreads,
-    keywords    = {user-level threading},
-    author      = {Kyle B. Wheeler and Richard C. Murphy and Douglas Thain},
-    title       = {Qthreads: An API for Programming with Millions of Lightweight Threads},
-    booktitle   = {International Symposium on Parallel and Distributed Processing},
-    organization= {IEEE},
-    address     = {Miami, FL, USA},
-    month       = apr,
-    year        = 2008,
+}
 @article{Grossman06,
 …
+}
-@manual{Quasar,
-    keywords    = {Quasar},
-    contributer = {pabuhr@plg},
-    author      = {Quasar},
-    title       = {Quasar Documentation, Release 0.8.0},
-    organization= {Parallel Universe},
-    address     = {\href{http://docs.paralleluniverse.co/quasar}{http://\-docs.paralleluniverse.co/\-quasar}},
-    year        = 2018,
+}
 % R
 …
     number      = 10,
     pages       = {27-32},
+}
-@article{Hesselink06,
-    author      = {Wim H. Hesselink},
-    title       = {Refinement Verification of the Lazy Caching Algorithm},
-    journal     = acta,
-    year        = 2006,
-    month       = oct,
-    volume      = 43,
-    number      = 3,
-    pages       = {195--222},
+}
 …
+}
-@manual{Ruby,
-    keywords    = {Ruby},
-    contributer = {pabuhr@plg},
-    author      = {Ruby},
-    title       = {Ruby Documentation, Release 2.6.0},
-    organization= {Python Software Foundation},
-    address     = {\href{https://www.ruby-lang.org/en/documentation}{https://\-www.ruby-lang.org/\-en/\-documentation}},
-    year        = 2018,
+}
 % S
 …
+}
-@article{SysVABI,
-  keywords = {System V ABI},
-  contributer = {a3moss@uwaterloo.ca},
-  title={System {V} application binary interface},
-  author={Matz, Michael and Hubicka, Jan and Jaeger, Andreas and Mitchell, Mark},
-  journal={AMD64 Architecture Processor Supplement, Draft v0},
-  volume={99},
-  year={2013}
+}
 % T
 …
     author      = {{TIOBE Index}},
     howpublished= {\href{http://www.tiobe.com/tiobe_index}{http://\-www.tiobe.com/\-tiobe\_index}},
+}
+@misc{ThreadModel,
+    contributer = {pabuhr@plg},
+    key         = {ThreadModel},
+    title       = {Thread (computing)},
+    author      = {{Threading Model}},
+    howpublished= {\href{https://en.wikipedia.org/wiki/Thread_(computing)}{https://\-en.wikipedia.org/\-wiki/\-Thread\_(computing)}},
+    optnote     = {Accessed: 2018-09},
+}
 …
+}
-@techreport{Black90,
-  title={Typechecking polymorphism in {Emerald}},
-  author={Black, Andrew P and Hutchinson, Norman C},
-  year={1990},
-  institution={Cambridge Research Laboratory, Digital Equipment Corporation}
+}
 @article{Cormack90,
     keywords    = {polymorphism},
 …
     year        = 2017,
     howpublished= {\url{https://wiki.gnome.org/Projects/Vala/Manual}},
+    optnote     = {Accessed: 2017-04}
+}
 …
 % Y
-@article{Boehm12,
-    keywords    = {memory model, race condition},
-    contributer = {pabuhr@plg},
-    author      = {Boehm, Hans-J. and Adve, Sarita V.},
-    title       = {You Don'T Know Jack About Shared Variables or Memory Models},
-    journal     = cacm,
-    volume      = 55,
-    number      = 2,
-    month       = feb,
-    year        = 2012,
-    pages       = {48--54},
-    publisher   = {ACM},
-    address     = {New York, NY, USA},
+}
 % Z

doc/papers/concurrency/Paper.tex

-              r933f32f
+              r6a9d4b4
 {}
 \lstnewenvironment{Go}[1][]
+{\lstset{language=go,moredelim=**[is][\protect\color{red}]{`}{`},#1}\lstset{#1}}
+{}
+\lstnewenvironment{python}[1][]
+{\lstset{language=python,moredelim=**[is][\protect\color{red}]{`}{`},#1}\lstset{#1}}
+{\lstset{#1}}
 {}
 …
+}
 \title{\texorpdfstring{Advanced Control-flow and Concurrency in \protect\CFA}{Advanced Control-flow in Cforall}}
+\title{\texorpdfstring{Concurrency in \protect\CFA}{Concurrency in Cforall}}
 \author[1]{Thierry Delisle}
 …
 \corres{*Peter A. Buhr, Cheriton School of Computer Science, University of Waterloo, 200 University Avenue West, Waterloo, ON, N2L 3G1, Canada. \email{pabuhr{\char`\@}uwaterloo.ca}}
 % \fundingInfo{Natural Sciences and Engineering Research Council of Canada}
+\fundingInfo{Natural Sciences and Engineering Research Council of Canada}
 \abstract[Summary]{
+\CFA is a polymorphic, non-object-oriented, concurrent, backwards-compatible extension of the C programming language.
+This paper discusses the design philosophy and implementation of its advanced control-flow and concurrent/parallel features, along with the supporting runtime.
+These features are created from scratch as ISO C has only low-level and/or unimplemented concurrency, so C programmers continue to rely on library features like C pthreads.
+\CFA introduces modern language-level control-flow mechanisms, like coroutines, user-level threading, and monitors for mutual exclusion and synchronization.
+Library extension for executors, futures, and actors are built on these basic mechanisms.
+The runtime provides significant programmer simplification and safety by eliminating spurious wakeup and reducing monitor barging.
+The runtime also ensures multiple monitors can be safely acquired \emph{simultaneously} (deadlock free), and this feature is fully integrated with all monitor synchronization mechanisms.
+All language features integrate with the \CFA polymorphic type-system and exception handling, while respecting the expectations and style of C programmers.
+\CFA is a modern, polymorphic, \emph{non-object-oriented} extension of the C programming language.
+This paper discusses the design of the concurrency and parallelism features in \CFA, and its concurrent runtime-system.
+These features are created from scratch as ISO C lacks concurrency, relying largely on the pthreads library for concurrency.
+Coroutines and lightweight (user) threads are introduced into \CFA;
+as well, monitors are added as a high-level mechanism for mutual exclusion and synchronization.
+A unique contribution of this work is allowing multiple monitors to be safely acquired \emph{simultaneously}.
+All features respect the expectations of C programmers, while being fully integrate with the \CFA polymorphic type-system and other language features.
 Experimental results show comparable performance of the new features with similar mechanisms in other concurrent programming-languages.
 }%
 \keywords{coroutines, concurrency, parallelism, threads, monitors, runtime, C, \CFA (Cforall)}
+\keywords{concurrency, parallelism, coroutines, threads, monitors, runtime, C, Cforall}
 …
 \section{Introduction}
-This paper discusses the design philosophy and implementation of advanced language-level control-flow and concurrent/parallel features in \CFA~\cite{Moss18} and its runtime.
-\CFA is a modern, polymorphic, non-object-oriented\footnote{
-\CFA has features often associated with object-oriented programming languages, such as constructors, destructors, virtuals and simple inheritance.
-However, functions \emph{cannot} be nested in structures, so there is no lexical binding between a structure and set of functions (member/method) implemented by an implicit \lstinline@this@ (receiver) parameter.},
-backwards-compatible extension of the C programming language.
-Within the \CFA framework, new control-flow features are created from scratch.
-ISO \Celeven defines only a subset of the \CFA extensions, where the overlapping features are concurrency~\cite[\S~7.26]{C11}.
-However, \Celeven concurrency is largely wrappers for a subset of the pthreads library~\cite{Butenhof97,Pthreads}.
-Furthermore, \Celeven and pthreads concurrency is simple, based on thread fork/join in a function and a few locks, which is low-level and error prone;
-no high-level language concurrency features are defined.
-Interestingly, almost a decade after publication of the \Celeven standard, neither gcc-8, clang-8 nor msvc-19 (most recent versions) support the \Celeven include @threads.h@, indicating little interest in the C11 concurrency approach.
-Finally, while the \Celeven standard does not state a threading model, the historical association with pthreads suggests implementations would adopt kernel-level threading (1:1)~\cite{ThreadModel}.
-In contrast, there has been a renewed interest during the past decade in user-level (M:N, green) threading in old and new programming languages.
-As multi-core hardware became available in the 1980/90s, both user and kernel threading were examined.
-Kernel threading was chosen, largely because of its simplicity and fit with the simpler operating systems and hardware architectures at the time, which gave it a performance advantage~\cite{Drepper03}.
-Libraries like pthreads were developed for C, and the Solaris operating-system switched from user (JDK 1.1~\cite{JDK1.1}) to kernel threads.
-As a result, languages like Java, Scala~\cite{Scala}, Objective-C~\cite{obj-c-book}, \CCeleven~\cite{C11}, and C\#~\cite{Csharp} adopt the 1:1 kernel-threading model, with a variety of presentation mechanisms.
-From 2000 onwards, languages like Go~\cite{Go}, Erlang~\cite{Erlang}, Haskell~\cite{Haskell}, D~\cite{D}, and \uC~\cite{uC++,uC++book} have championed the M:N user-threading model, and many user-threading libraries have appeared~\cite{Qthreads,MPC,BoostThreads}, including putting green threads back into Java~\cite{Quasar}.
-The main argument for user-level threading is that they are lighter weight than kernel threads (locking and context switching do not cross the kernel boundary), so there is less restriction on programming styles that encourage large numbers of threads performing smaller work-units to facilitate load balancing by the runtime~\cite{Verch12}.
-As well, user-threading facilitates a simpler concurrency approach using thread objects that leverage sequential patterns versus events with call-backs~\cite{vonBehren03}.
-Finally, performant user-threading implementations (both time and space) are largely competitive with direct kernel-threading implementations, while achieving the programming advantages of high concurrency levels and safety.
-A further effort over the past two decades is the development of language memory-models to deal with the conflict between language features and compiler/hardware optimizations, i.e., some language features are unsafe in the presence of aggressive sequential optimizations~\cite{Buhr95a,Boehm05}.
-The consequence is that a language must provide sufficient tools to program around safety issues, as inline and library code is all sequential to the compiler.
-One solution is low-level qualifiers and functions (e.g., @volatile@ and atomics) allowing \emph{programmers} to explicitly write safe (race-free~\cite{Boehm12}) programs.
-A safer solution is high-level language constructs so the \emph{compiler} knows the optimization boundaries, and hence, provides implicit safety.
-This problem is best know with respect to concurrency, but applies to other complex control-flow, like exceptions\footnote{
-\CFA exception handling will be presented in a separate paper.
-The key feature that dovetails with this paper is non-local exceptions allowing exceptions to be raised across stacks, with synchronous exceptions raised among coroutines and asynchronous exceptions raised among threads, similar to that in \uC~\cite[\S~5]{uC++}
-} and coroutines.
-Finally, solutions in the language allows matching constructs with language paradigm, i.e., imperative and functional languages have different presentations of the same concept.
-Finally, it is important for a language to provide safety over performance \emph{as the default}, allowing careful reduction of safety for performance when necessary.
-Two concurrency violations of this philosophy are \emph{spurious wakeup} and \emph{barging}, i.e., random wakeup~\cite[\S~8]{Buhr05a} and signalling-as-hints~\cite[\S~8]{Buhr05a}, where one begats the other.
-If you believe spurious wakeup is a foundational concurrency property, than unblocking (signalling) a thread is always a hint.
-If you \emph{do not} believe spurious wakeup is foundational, than signalling-as-hints is a performance decision.
-Most importantly, removing spurious wakeup and signals-as-hints makes concurrent programming significantly safer because it removes local non-determinism.
-Clawing back performance where the local non-determinism is unimportant, should be an option not the default.
-\begin{comment}
-For example, it is possible to provide exceptions, coroutines, monitors, and tasks as specialized types in an object-oriented language, integrating these constructs to allow leveraging the type-system (static type-checking) and all other object-oriented capabilities~\cite{uC++}.
-It is also possible to leverage call/return for blocking communication via new control structures, versus switching to alternative communication paradigms, like channels or message passing.
-As well, user threading is often a complementary feature, allowing light-weight threading to match with low-cost objects, while hiding the application/kernel boundary.
-User threading also allows layering of implicit concurrency models (no explicit thread creation), such executors, data-flow, actors, into a single language, so programmers can chose the model that best fits an algorithm.\footnote{
-All implicit concurrency models have explicit threading in their implementation, and hence, can be build from explicit threading;
-however, the reverse is seldom true, i.e., given implicit concurrency, e.g., actors, it is virtually impossible to create explicit concurrency, e.g., blocking thread objects.}
-Finally, with extended language features and user-level threading it is possible to discretely fold locking and non-blocking I/O multiplexing into the language's I/O libraries, so threading implicitly dovetails with the I/O subsystem.
-\CFA embraces language extensions and user-level threading to provide advanced control-flow (exception handling\footnote{
-\CFA exception handling will be presented in a separate paper.
-The key feature that dovetails with this paper is non-local exceptions allowing exceptions to be raised across stacks, with synchronous exceptions raised among coroutines and asynchronous exceptions raised among threads, similar to that in \uC~\cite[\S~5]{uC++}
-} and coroutines) and concurrency.
-Most augmented traditional (Fortran 18~\cite{Fortran18}, Cobol 14~\cite{Cobol14}, Ada 12~\cite{Ada12}, Java 11~\cite{Java11}) and new languages (Go~\cite{Go}, Rust~\cite{Rust}, and D~\cite{D}), except \CC, diverge from C with different syntax and semantics, only interoperate indirectly with C, and are not systems languages, for those with managed memory.
-As a result, there is a significant learning curve to move to these languages, and C legacy-code must be rewritten.
-While \CC, like \CFA, takes an evolutionary approach to extend C, \CC's constantly growing complex and interdependent features-set (e.g., objects, inheritance, templates, etc.) mean idiomatic \CC code is difficult to use from C, and C programmers must expend significant effort learning \CC.
-Hence, rewriting and retraining costs for these languages, even \CC, are prohibitive for companies with a large C software-base.
-\CFA with its orthogonal feature-set, its high-performance runtime, and direct access to all existing C libraries circumvents these problems.
-\end{comment}
-\CFA embraces user-level threading, language extensions for advanced control-flow, and safety as the default.
-We present comparative examples so the reader can judge if the \CFA control-flow extensions are better and safer than those in or proposed for \Celeven, \CC and other concurrent, imperative programming languages, and perform experiments to show the \CFA runtime is competitive with other similar mechanisms.
-The main contributions of this work are:
-\begin{itemize}
-\item
-expressive language-level coroutines and user-level threading, which respect the expectations of C programmers.
-\item
-monitor synchronization without barging.
-\item
-safely acquiring multiple monitors \emph{simultaneously} (deadlock free), while seamlessly integrating this capability with all monitor synchronization mechanisms.
-\item
-providing statically type-safe interfaces that integrate with the \CFA polymorphic type-system and other language features.
-\item
-library extensions for executors, futures, and actors built on the basic mechanisms.
-\item
-a runtime system with no spurious wakeup.
-\item
-experimental results showing comparable performance of the new features with similar mechanisms in other concurrent programming-languages.
-\end{itemize}
-\begin{comment}
 This paper provides a minimal concurrency \newterm{Application Program Interface} (API) that is simple, efficient and can be used to build other concurrency features.
 While the simplest concurrency system is a thread and a lock, this low-level approach is hard to master.
 …
 The proposed concurrency API is implemented in a dialect of C, called \CFA (pronounced C-for-all).
 The paper discusses how the language features are added to the \CFA translator with respect to parsing, semantics, and type checking, and the corresponding high-performance runtime-library to implement the concurrent features.
+\end{comment}
+\begin{comment}
 \section{\CFA Overview}
 …
 \end{cfa}
 where the return type supplies the type/size of the allocation, which is impossible in most type systems.
+\end{comment}
+\section{Coroutines: Stepping Stone}
+\label{coroutine}
+\section{Concurrency}
+\label{s:Concurrency}
+At its core, concurrency is based on multiple call-stacks and scheduling threads executing on these stacks.
+Multiple call stacks (or contexts) and a single thread of execution, called \newterm{coroutining}~\cite{Conway63,Marlin80}, does \emph{not} imply concurrency~\cite[\S~2]{Buhr05a}.
+In coroutining, the single thread is self-scheduling across the stacks, so execution is deterministic, \ie the execution path from input to output is fixed and predictable.
+A \newterm{stackless} coroutine executes on the caller's stack~\cite{Python} but this approach is restrictive, \eg preventing modularization and supporting only iterator/generator-style programming;
+a \newterm{stackful} coroutine executes on its own stack, allowing full generality.
+Only stackful coroutines are a stepping stone to concurrency.
+The transition to concurrency, even for execution with a single thread and multiple stacks, occurs when coroutines also context switch to a \newterm{scheduling oracle}, introducing non-determinism from the coroutine perspective~\cite[\S~3]{Buhr05a}.
+Therefore, a minimal concurrency system is possible using coroutines (see Section \ref{coroutine}) in conjunction with a scheduler to decide where to context switch next.
+The resulting execution system now follows a cooperative threading-model, called \newterm{non-preemptive scheduling}.
+Because the scheduler is special, it can either be a stackless or stackful coroutine.
+For stackless, the scheduler performs scheduling on the stack of the current coroutine and switches directly to the next coroutine, so there is one context switch.
+For stackful, the current coroutine switches to the scheduler, which performs scheduling, and it then switches to the next coroutine, so there are two context switches.
+A stackful scheduler is often used for simplicity and security.
+Regardless of the approach used, a subset of concurrency related challenges start to appear.
+For the complete set of concurrency challenges to occur, the missing feature is \newterm{preemption}, where context switching occurs randomly between any two instructions, often based on a timer interrupt, called \newterm{preemptive scheduling}.
+While a scheduler introduces uncertainty in the order of execution, preemption introduces uncertainty about where context switches occur.
+Interestingly, uncertainty is necessary for the runtime (operating) system to give the illusion of parallelism on a single processor and increase performance on multiple processors.
+The reason is that only the runtime has complete knowledge about resources and how to best utilized them.
+However, the introduction of unrestricted non-determinism results in the need for \newterm{mutual exclusion} and \newterm{synchronization} to restrict non-determinism for correctness;
+otherwise, it is impossible to write meaningful programs.
+Optimal performance in concurrent applications is often obtained by having as much non-determinism as correctness allows.
+An important missing feature in C is threading\footnote{While the C11 standard defines a \protect\lstinline@threads.h@ header, it is minimal and defined as optional.
+As such, library support for threading is far from widespread.
+At the time of writing the paper, neither \protect\lstinline@gcc@ nor \protect\lstinline@clang@ support \protect\lstinline@threads.h@ in their standard libraries.}.
+In modern programming languages, a lack of threading is unacceptable~\cite{Sutter05, Sutter05b}, and therefore existing and new programming languages must have tools for writing efficient concurrent programs to take advantage of parallelism.
+As an extension of C, \CFA needs to express these concepts in a way that is as natural as possible to programmers familiar with imperative languages.
+Furthermore, because C is a system-level language, programmers expect to choose precisely which features they need and which cost they are willing to pay.
+Hence, concurrent programs should be written using high-level mechanisms, and only step down to lower-level mechanisms when performance bottlenecks are encountered.
+\subsection{Coroutines: A Stepping Stone}\label{coroutine}
+While the focus of this discussion is concurrency and parallelism, it is important to address coroutines, which are a significant building block of a concurrency system (but not concurrent among themselves).
 Coroutines are generalized routines allowing execution to be temporarily suspended and later resumed.
 Hence, unlike a normal routine, a coroutine may not terminate when it returns to its caller, allowing it to be restarted with the values and execution location present at the point of suspension.
 …
 \centering
 \newbox\myboxA
-% \begin{lrbox}{\myboxA}
-% \begin{cfa}[aboveskip=0pt,belowskip=0pt]
-% `int fn1, fn2, state = 1;`   // single global variables
-% int fib() {
-%       int fn;
-%       `switch ( state )` {  // explicit execution state
-%         case 1: fn = 0;  fn1 = fn;  state = 2;  break;
-%         case 2: fn = 1;  fn2 = fn1;  fn1 = fn;  state = 3;  break;
-%         case 3: fn = fn1 + fn2;  fn2 = fn1;  fn1 = fn;  break;
-%       }
-%       return fn;
-% }
-% int main() {
+%
-%       for ( int i = 0; i < 10; i += 1 ) {
-%               printf( "%d\n", fib() );
-%       }
-% }
-% \end{cfa}
-% \end{lrbox}
 \begin{lrbox}{\myboxA}
 \begin{cfa}[aboveskip=0pt,belowskip=0pt]
+#define FIB_INIT { 0, 1 }
+typedef struct { int fn1, fn; } Fib;
+`int f1, f2, state = 1;`   // single global variables
+int fib() {
+        int fn;
+        `switch ( state )` {  // explicit execution state
+          case 1: fn = 0;  f1 = fn;  state = 2;  break;
+          case 2: fn = 1;  f2 = f1;  f1 = fn;  state = 3;  break;
+          case 3: fn = f1 + f2;  f2 = f1;  f1 = fn;  break;
+        }
+        return fn;
+}
+int main() {
+        for ( int i = 0; i < 10; i += 1 ) {
+                printf( "%d\n", fib() );
+        }
+}
+\end{cfa}
+\end{lrbox}
+\newbox\myboxB
+\begin{lrbox}{\myboxB}
+\begin{cfa}[aboveskip=0pt,belowskip=0pt]
+#define FIB_INIT `{ 0, 1 }`
+typedef struct { int f2, f1; } Fib;
 int fib( Fib * f ) {
+        int ret = f->fn1;
+        f->fn1 = f->fn;
+        f->fn = ret + f->fn;
+        int ret = f->f2;
+        int fn = f->f1 + f->f2;
+        f->f2 = f->f1; f->f1 = fn;
         return ret;
+}
 int main() {
         Fib f1 = FIB_INIT, f2 = FIB_INIT;
         for ( int i = 0; i < 10; i += 1 ) {
+                printf( "%d %d\n",
+                                fib( &f1 ), fib( &f2 ) );
+                printf( "%d %d\n", fib( &f1 ), fib( &f2 ) );
+        }
+}
 …
 \end{lrbox}
+\subfloat[3 States: global variables]{\label{f:GlobalVariables}\usebox\myboxA}
+\qquad
+\subfloat[1 State: external variables]{\label{f:ExternalState}\usebox\myboxB}
+\caption{C Fibonacci Implementations}
+\label{f:C-fibonacci}
+\bigskip
+\newbox\myboxA
+\begin{lrbox}{\myboxA}
+\begin{cfa}[aboveskip=0pt,belowskip=0pt]
+`coroutine` Fib { int fn; };
+void main( Fib & fib ) with( fib ) {
+        int f1, f2;
+        fn = 0;  f1 = fn;  `suspend()`;
+        fn = 1;  f2 = f1;  f1 = fn;  `suspend()`;
+        for ( ;; ) {
+                fn = f1 + f2;  f2 = f1;  f1 = fn;  `suspend()`;
+        }
+}
+int next( Fib & fib ) with( fib ) {
+        `resume( fib );`
+        return fn;
+}
+int main() {
+        Fib f1, f2;
+        for ( int i = 1; i <= 10; i += 1 ) {
+                sout | next( f1 ) | next( f2 );
+        }
+}
+\end{cfa}
+\end{lrbox}
 \newbox\myboxB
 \begin{lrbox}{\myboxB}
 \begin{cfa}[aboveskip=0pt,belowskip=0pt]
 `coroutine` Fib { int fn1; };
 void main( Fib & fib ) with( fib ) {
         int fn;
         [fn1, fn] = [0, 1];
         for () {
+                `suspend();`
                 [fn1, fn] = [fn, fn1 + fn];
+`coroutine` Fib { int ret; };
+void main( Fib & f ) with( fib ) {
+        int fn, f1 = 1, f2 = 0;
+        for ( ;; ) {
+                ret = f2;
+                fn = f1 + f2;  f2 = f1;  f1 = fn; `suspend();`
+        }
+}
 int ?()( Fib & fib ) with( fib ) {
         `resume( fib );`  return fn1;
+}
+int main() {
+        Fib f1, f2;
+        for ( 10 ) {
+                sout | f1() | f2();
+}
+int next( Fib & fib ) with( fib ) {
+        `resume( fib );`
+        return ret;
+}
 \end{cfa}
 \end{lrbox}
+\newbox\myboxC
+\begin{lrbox}{\myboxC}
+\begin{python}[aboveskip=0pt,belowskip=0pt]
+def Fib():
+    fn1, fn = 0, 1
+    while True:
+        `yield fn1`
+        fn1, fn = fn, fn1 + fn
+// next prewritten
+f1 = Fib()
+f2 = Fib()
+for i in range( 10 ):
+        print( next( f1 ), next( f2 ) )
+\end{python}
+\end{lrbox}
+\subfloat[C]{\label{f:GlobalVariables}\usebox\myboxA}
+\hspace{3pt}
+\vrule
+\hspace{3pt}
+\subfloat[\CFA]{\label{f:ExternalState}\usebox\myboxB}
+\hspace{3pt}
+\vrule
+\hspace{3pt}
+\subfloat[Python]{\label{f:ExternalState}\usebox\myboxC}
+\caption{Fibonacci Generator}
+\label{f:C-fibonacci}
+% \bigskip
+%
+% \newbox\myboxA
+% \begin{lrbox}{\myboxA}
+% \begin{cfa}[aboveskip=0pt,belowskip=0pt]
+% `coroutine` Fib { int fn; };
+% void main( Fib & fib ) with( fib ) {
+%       fn = 0;  int fn1 = fn; `suspend()`;
+%       fn = 1;  int fn2 = fn1;  fn1 = fn; `suspend()`;
+%       for () {
+%               fn = fn1 + fn2; fn2 = fn1; fn1 = fn; `suspend()`; }
+% }
+% int next( Fib & fib ) with( fib ) { `resume( fib );` return fn; }
+% int main() {
+%       Fib f1, f2;
+%       for ( 10 )
+%               sout | next( f1 ) | next( f2 );
+% }
+% \end{cfa}
+% \end{lrbox}
+% \newbox\myboxB
+% \begin{lrbox}{\myboxB}
+% \begin{python}[aboveskip=0pt,belowskip=0pt]
+%
+% def Fibonacci():
+%       fn = 0; fn1 = fn; `yield fn`  # suspend
+%       fn = 1; fn2 = fn1; fn1 = fn; `yield fn`
+%       while True:
+%               fn = fn1 + fn2; fn2 = fn1; fn1 = fn; `yield fn`
+%
+%
+% f1 = Fibonacci()
+% f2 = Fibonacci()
+% for i in range( 10 ):
+%       print( `next( f1 )`, `next( f2 )` ) # resume
+%
+% \end{python}
+% \end{lrbox}
+% \subfloat[\CFA]{\label{f:Coroutine3States}\usebox\myboxA}
+% \qquad
+% \subfloat[Python]{\label{f:Coroutine1State}\usebox\myboxB}
+% \caption{Fibonacci input coroutine, 3 states, internal variables}
+% \label{f:cfa-fibonacci}
+\subfloat[3 States, internal variables]{\label{f:Coroutine3States}\usebox\myboxA}
+\qquad\qquad
+\subfloat[1 State, internal variables]{\label{f:Coroutine1State}\usebox\myboxB}
+\caption{\CFA Coroutine Fibonacci Implementations}
+\label{f:cfa-fibonacci}
 \end{figure}
 …
 \begin{lrbox}{\myboxA}
 \begin{cfa}[aboveskip=0pt,belowskip=0pt]
 `coroutine` Fmt {
         char ch;   // communication variables
         int g, b;   // needed in destructor
+`coroutine` Format {
+        char ch;   // used for communication
+        int g, b;  // global because used in destructor
 };
 void main( Fmt & fmt ) with( fmt ) {
         for () {
                 for ( g = 0; g < 5; g += 1 ) { // groups
                         for ( b = 0; b < 4; b += 1 ) { // blocks
+void main( Format & fmt ) with( fmt ) {
+        for ( ;; ) {
+                for ( g = 0; g < 5; g += 1 ) {      // group
+                        for ( b = 0; b < 4; b += 1 ) { // block
                                 `suspend();`
+                                sout | ch; } // print character
+                        sout | "  "; } // block separator
+                sout | nl; }  // group separator
+}
+void ?{}( Fmt & fmt ) { `resume( fmt );` } // prime
+void ^?{}( Fmt & fmt ) with( fmt ) { // destructor
+        if ( g != 0 || b != 0 ) // special case
+                sout | nl; }
+void send( Fmt & fmt, char c ) { fmt.ch = c; `resume( fmt )`; }
+                                sout | ch;              // separator
+                        }
+                        sout | "  ";               // separator
+                }
+                sout | nl;
+        }
+}
+void ?{}( Format & fmt ) { `resume( fmt );` }
+void ^?{}( Format & fmt ) with( fmt ) {
+        if ( g != 0 || b != 0 ) sout | nl;
+}
+void format( Format & fmt ) {
+        `resume( fmt );`
+}
 int main() {
+        Fmt fmt;
+        sout | nlOff;   // turn off auto newline
+        for ( 41 )
+                send( fmt, 'a' );
+        Format fmt;
+        eof: for ( ;; ) {
+                sin | fmt.ch;
+          if ( eof( sin ) ) break eof;
+                format( fmt );
+        }
+}
 \end{cfa}
 …
 \newbox\myboxB
 \begin{lrbox}{\myboxB}
+\begin{python}[aboveskip=0pt,belowskip=0pt]
+def Fmt():
+        try:
+                while True:
+                        for g in range( 5 ):
+                                for b in range( 4 ):
+                                        print( `(yield)`, end='' )
+                                print( '  ', end='' )
+                        print()
+        except GeneratorExit:
+                if g != 0 | b != 0:
+                        print()
+fmt = Fmt()
+`next( fmt )`                    # prime
+for i in range( 41 ):
+        `fmt.send( 'a' );`      # send to yield
+\end{python}
+\begin{cfa}[aboveskip=0pt,belowskip=0pt]
+struct Format {
+        char ch;
+        int g, b;
+};
+void format( struct Format * fmt ) {
+        if ( fmt->ch != -1 ) {      // not EOF ?
+                printf( "%c", fmt->ch );
+                fmt->b += 1;
+                if ( fmt->b == 4 ) {  // block
+                        printf( "  " );      // separator
+                        fmt->b = 0;
+                        fmt->g += 1;
+                }
+                if ( fmt->g == 5 ) {  // group
+                        printf( "\n" );     // separator
+                        fmt->g = 0;
+                }
+        } else {
+                if ( fmt->g != 0 || fmt->b != 0 ) printf( "\n" );
+        }
+}
+int main() {
+        struct Format fmt = { 0, 0, 0 };
+        for ( ;; ) {
+                scanf( "%c", &fmt.ch );
+          if ( feof( stdin ) ) break;
+                format( &fmt );
+        }
+        fmt.ch = -1;
+        format( &fmt );
+}
+\end{cfa}
 \end{lrbox}
 \subfloat[\CFA]{\label{f:CFAFmt}\usebox\myboxA}
+\subfloat[\CFA Coroutine]{\label{f:CFAFmt}\usebox\myboxA}
 \qquad
 \subfloat[Python]{\label{f:CFmt}\usebox\myboxB}
 \caption{Output formatting text}
+\subfloat[C Linearized]{\label{f:CFmt}\usebox\myboxB}
+\caption{Formatting text into lines of 5 blocks of 4 characters.}
 \label{f:fmt-line}
 \end{figure}
 …
 void main( Prod & prod ) with( prod ) {
         // 1st resume starts here
         for ( i; N ) {
+        for ( int i = 0; i < N; i += 1 ) {
                 int p1 = random( 100 ), p2 = random( 100 );
                 sout | p1 | " " | p2;
 …
+}
 void start( Prod & prod, int N, Cons &c ) {
         &prod.c = &c; // reassignable reference
+        &prod.c = &c;
         prod.[N, receipt] = [N, 0];
         `resume( prod );`
 …
         Prod & p;
         int p1, p2, status;
         bool done;
+        _Bool done;
 };
 void ?{}( Cons & cons, Prod & p ) {
         &cons.p = &p; // reassignable reference
+        &cons.p = &p;
         cons.[status, done ] = [0, false];
+}
 …
 @start@ returns and the program main terminates.
-One \emph{killer} application for a coroutine is device drivers, which at one time caused 70\%-85\% of failures in Windows/Linux~\cite{Swift05}.
-Many device drivers are a finite state-machine parsing a protocol, e.g.:
-\begin{tabbing}
-\ldots STX \= \ldots message \ldots \= ESC \= ETX \= \ldots message \ldots  \= ETX \= 2-byte crc \= \ldots      \kill
-\ldots STX \> \ldots message \ldots \> ESC \> ETX \> \ldots message \ldots  \> ETX \> 2-byte crc \> \ldots
-\end{tabbing}
-where a network message begins with the control character STX and ends with an ETX, followed by a 2-byte cyclic-redundancy check.
-Control characters may appear in a message if preceded by an ESC.
-Because FSMs can be complex and occur frequently in important domains, direct support of the coroutine is crucial in a systems programminglanguage.
-\begin{figure}
-\begin{cfa}
-enum Status { CONT, MSG, ESTX, ELNTH, ECRC };
-`coroutine` Driver {
-        Status status;
-        char * msg, byte;
-};
-void ?{}( Driver & d, char * m ) { d.msg = m; }         $\C[3.0in]{// constructor}$
-Status next( Driver & d, char b ) with( d ) {           $\C{// 'with' opens scope}$
-        byte = b; `resume( d );` return status;
+}
-void main( Driver & d ) with( d ) {
-        enum { STX = '\002', ESC = '\033', ETX = '\003', MaxMsg = 64 };
-        unsigned short int crc;                                                 $\C{// error checking}$
-  msg: for () {                                                                         $\C{// parse message}$
-                status = CONT;
-                unsigned int lnth = 0, sum = 0;
-                while ( byte != STX ) `suspend();`
-          emsg: for () {
-                        `suspend();`                                                    $\C{// process byte}$
-                        choose ( byte ) {                                               $\C{// switch with default break}$
-                          case STX:
-                                status = ESTX; `suspend();` continue msg;
-                          case ETX:
-                                break emsg;
-                          case ESC:
-                                suspend();
-                        } // choose
-                        if ( lnth >= MaxMsg ) {                                 $\C{// buffer full ?}$
-                                status = ELNTH; `suspend();` continue msg; }
-                        msg[lnth++] = byte;
-                        sum += byte;
-                } // for
-                msg[lnth] = '\0';                                                       $\C{// terminate string}\CRT$
-                `suspend();`
-                crc = (unsigned char)byte << 8; // prevent sign extension for signed char
-                `suspend();`
-                status = (crc | (unsigned char)byte) == sum ? MSG : ECRC;
-                `suspend();`
-        } // for
+}
-\end{cfa}
-\caption{Device driver for simple communication protocol}
-\end{figure}
 \subsection{Coroutine Implementation}
 …
 \end{cquote}
 The combination of these two approaches allows an easy and concise specification to coroutining (and concurrency) for normal users, while more advanced users have tighter control on memory layout and initialization.
-\section{Concurrency}
-\label{s:Concurrency}
-At its core, concurrency is based on multiple call-stacks and scheduling threads executing on these stacks.
-Multiple call stacks (or contexts) and a single thread of execution, called \newterm{coroutining}~\cite{Conway63,Marlin80}, does \emph{not} imply concurrency~\cite[\S~2]{Buhr05a}.
-In coroutining, the single thread is self-scheduling across the stacks, so execution is deterministic, \ie the execution path from input to output is fixed and predictable.
-A \newterm{stackless} coroutine executes on the caller's stack~\cite{Python} but this approach is restrictive, \eg preventing modularization and supporting only iterator/generator-style programming;
-a \newterm{stackful} coroutine executes on its own stack, allowing full generality.
-Only stackful coroutines are a stepping stone to concurrency.
-The transition to concurrency, even for execution with a single thread and multiple stacks, occurs when coroutines also context switch to a \newterm{scheduling oracle}, introducing non-determinism from the coroutine perspective~\cite[\S~3]{Buhr05a}.
-Therefore, a minimal concurrency system is possible using coroutines (see Section \ref{coroutine}) in conjunction with a scheduler to decide where to context switch next.
-The resulting execution system now follows a cooperative threading-model, called \newterm{non-preemptive scheduling}.
-Because the scheduler is special, it can either be a stackless or stackful coroutine.
-For stackless, the scheduler performs scheduling on the stack of the current coroutine and switches directly to the next coroutine, so there is one context switch.
-For stackful, the current coroutine switches to the scheduler, which performs scheduling, and it then switches to the next coroutine, so there are two context switches.
-A stackful scheduler is often used for simplicity and security.
-Regardless of the approach used, a subset of concurrency related challenges start to appear.
-For the complete set of concurrency challenges to occur, the missing feature is \newterm{preemption}, where context switching occurs randomly between any two instructions, often based on a timer interrupt, called \newterm{preemptive scheduling}.
-While a scheduler introduces uncertainty in the order of execution, preemption introduces uncertainty about where context switches occur.
-Interestingly, uncertainty is necessary for the runtime (operating) system to give the illusion of parallelism on a single processor and increase performance on multiple processors.
-The reason is that only the runtime has complete knowledge about resources and how to best utilized them.
-However, the introduction of unrestricted non-determinism results in the need for \newterm{mutual exclusion} and \newterm{synchronization} to restrict non-determinism for correctness;
-otherwise, it is impossible to write meaningful programs.
-Optimal performance in concurrent applications is often obtained by having as much non-determinism as correctness allows.
-An important missing feature in C is threading\footnote{While the C11 standard defines a \protect\lstinline@threads.h@ header, it is minimal and defined as optional.
-As such, library support for threading is far from widespread.
-At the time of writing the paper, neither \protect\lstinline@gcc@ nor \protect\lstinline@clang@ support \protect\lstinline@threads.h@ in their standard libraries.}.
-In modern programming languages, a lack of threading is unacceptable~\cite{Sutter05, Sutter05b}, and therefore existing and new programming languages must have tools for writing efficient concurrent programs to take advantage of parallelism.
-As an extension of C, \CFA needs to express these concepts in a way that is as natural as possible to programmers familiar with imperative languages.
-Furthermore, because C is a system-level language, programmers expect to choose precisely which features they need and which cost they are willing to pay.
-Hence, concurrent programs should be written using high-level mechanisms, and only step down to lower-level mechanisms when performance bottlenecks are encountered.

doc/papers/concurrency/mail

-              r933f32f
+              r6a9d4b4
 Software: Practice and Experience Editorial Office
-Date: Wed, 3 Oct 2018 21:25:28 +0000
-From: Richard Jones <onbehalfof@manuscriptcentral.com>
-Reply-To: R.E.Jones@kent.ac.uk
-To: tdelisle@uwaterloo.ca, pabuhr@uwaterloo.ca
-Subject: Software: Practice and Experience - Decision on Manuscript ID
- SPE-18-0205
--Oct-2018
-Dear Dr Buhr,
-Many thanks for submitting SPE-18-0205 entitled "Concurrency in C∀" to Software: Practice and Experience.
-In view of the comments of the referees found at the bottom of this letter, I cannot accept your paper for publication in Software: Practice and Experience. I hope that you find the referees' very detailed comments helpful.
-Thank you for considering Software: Practice and Experience for the publication of your research.  I hope the outcome of this specific submission will not discourage you from submitting future manuscripts.
-Yours sincerely,
-Prof. Richard Jones
-Editor, Software: Practice and Experience
-R.E.Jones@kent.ac.uk
-Referee(s)' Comments to Author:
-Reviewing: 1
-Comments to the Author
-"Concurrency in Cforall" presents a design and implementation of a set of standard concurrency features, including coroutines, user-space and kernel-space threads, mutexes, monitors, and a scheduler, for a polymorphic derivation of C called Cforall.
-Section 2 is an overview of sequential Cforall that does not materially contribute to the paper. A brief syntax explanation where necessary in examples would be plenty.
-Section 3 begins with with an extensive discussion of concurrency that also does not materially contribute to the paper. A brief mention of whether a particular approach implements cooperative or preemptive scheduling would be sufficient. Section 3 also makes some unfortunate claims, such as C not having threads -- C does in fact define threads, and this is noted as being true in a footnote, immediately after claiming that it does not. The question remains why the C11 parallelism design is insufficient and in what way this paper proposes to augment it. While I am personally a proponent of parallel programming languages, backing the assertion that all modern languages must have threading with citations from 2005 ignores the massive popularity of modern non-parallel languages (Javascript, node.js, Typescript, Python, Ruby, etc.) and parallel languages that are not thread based, although the authors are clearly aware of such approaches.
-Sections 3.1 and 3.2 dicusses assymetric and symmetric coroutines. This also does not seem to materially contribute to a paper that is ostensibly about concurrency in a modern systems programming language. The area of coroutines, continuations, and generators is already well explored in the context of systems languages, including compilation techniques for these constructs that are more advanced than the stack instantiation model discussed in the paper.
-Section 3.3 describes threads in Cforall, briefly touching on user-space vs. kernel-space thread implementations without detailing the extensive practical differences. It is unclear how the described interface differes from C++11 threads, as the description seems to center on an RAII style approach to joining in the destructor.
-Section 4 briefly touches on a collection of well known synchronisation primitives. Again, this discussion does not materially contribute to the paper.
-Section 5 describes monitors, which are a well known and well researched technique. The Cforall implementation is unsurprising. The "multi-acquire semantics" described are not a contribution of this paper, as establishing a stable order for lock acquisition is a well known technique, one example of which is the C++ std::scoped_lock.
-Section 6 is a discussion of scheduling that does not appear to be informed by the literature. There is no discussion of work-stealing vs. work-scheduling, static vs. dynamic priorities, priority inversion, or fairness. There is a claim in secion 6.1 for a novel technique, partial signalling, that appears to be a form of dynamic priority, but no comparison is made. In section 6.6, a very brief mention of other synchronisation techniques is made, without reference to current techniques such as array-based locks, CLH or MCS queue locks, RCU and other epoch-based mechanisms, etc. Perhaps these are considered out of scope.
-Section 7 discusses parallelism, but does not materially contribute to the paper. It is claimed that preemption is necessary to implement spinning, which is not correct, since two cores can implement a spinning based approach without preemption. It is claimed that with thread pools "concurrency errors return", but no approach to removing concurrency errors with either preemptive or cooperatively scheduled user threads has been proposed in the paper that would not also apply to thread pools.
-Section 8 is intended to describe the Cforall runtime structure, but does so in a way that uses terminology in an unfamiliar way. The word cluster is more usually used in distributed systems, but here refers to a process. The term virtual processor is more usually used in hardware virtualisation, but here refers to a kernel thread. The term debug kernel is more usually used in operating systems to refer to kernels that have both debug info and a method for using a debugger in kernel space, but here refers to a debug build of a user-space process. This section does not materially contribute to the paper.
-Section 9 is intended to describe the Cforall runtime implementation. It makes some unusual claims, such as C libraries migrating to stack chaining (stack chaining was an experimental GCC feature that has been abandoned, much as it has been abandoned in both Go and Rust).
-The performance measurements in section 10 are difficult to evaluate. While I appreciate that comparable concurrency benchmarks are very difficult to write, and the corpus of existing benchmarks primarily boils down to the parallel programs in the Computer Language Benchmark Game, the lack of detail as to what is being measured in these benchmarks (particularly when implemented in other languages) is unfortunate. For example, in table 3, the benchmark appears to measure uncontended lock access, which is not a useful micro-benchmark.
-It is not clear what the contributions of this paper are intended to be. A concise listing of the intended contributions would be helpful. Currently, it appears that the paper makes neither PL contributions in terms of novel features in Cforall, nor does it make systems contributions in terms of novel features in the runtime.
-Reviewing: 2
-Comments to the Author
-This article presents the design and rationale behind the concurrency
-features of C-forall, a new low-level programming language.  After an
-introduction that defines a selection of standard terminology, section
-gives crucial background on the design of the C-forall language.
-Section 3 then starts the core of the article, discussing the
-language's support for "concurrency" which in this case means
-coroutines and threads; a very brief Section 4 builds on section 3
-with a discussion of lower level synchronizations.  Section 5 the
-presents the main features of concurrency control in C-forall:
-monitors and mutexes. Section 6 then extends monitors with condition
-variables to to support scheduling, and a very brief section 7
-discusses preemption and pooling. Section 8 discusses the runtime
-conceptual model, section 9 gives implementation detail, and section
-briefly evaluates C-forall's performance via five concurrent
-micro benchmarks. Finally section 11 concludes the article, and then
-section 12 presents some future work.
-At the start of section 7, article lays out its rationale: that while
-"historically, computer performance was about processor speeds" but
-"Now, high-performance applications must care about parallelism,
-which requires concurrency". The doomsayers trumpeting the death of
-Moore's law have been proved correct at last, with CPUs sequential
-performance increasing much more slowly than the number of cores
-within each die. This means programmers --- especially low-level,
-systems programmers --- must somehow manage the essential complexity
-of writing concurrent programs to run in parallel in multiple threads
-across multiple cores. Unfortunately, the most venerable widely used
-systems programming language, C, supports parallelism only via an
-e.g. the threads library.  This article aims to integrate concurrent
-programming mechanisms more closely into a novel low-level C-based
-programming language, C-forall. The article gives an outline of much of
-C-forall, presents a series of concurrency mechanisms, and finally
-some microbenchmark results.  The article is detailed, comprehensive,
-and generally well written in understandable English.
-My main concern about the article are indicated by the fact that the
-best summary of the problem the design of concurrent C-forall sets
-out to solve is buried more than halfway through the article in section
-, as above, and then the best overview of the proposed solution is
-given in the 2nd, 4th and 5th sentence of the conclusion:
-   "The approach provides concurrency based on a preemptive M:N
-    user-level threading-system, executing in clusters, which
-    encapsulate scheduling of work on multiple kernel threads
-    providing parallelism... High-level objects (monitor/task) are the
-    core mechanism for mutual exclusion and synchronization. A novel
-    aspect is allowing multiple mutex-objects to be accessed
-    simultaneously reducing the potential for deadlock for this
-    complex scenario."
-That is, in my reading of the article, it proceeds bottom up rather
-than top down, and so my main recommendation is to essentially reverse
-the order of the article, proceeding from the problem to be solved,
-the high level architecture of the proposed solutions, and then going
-down to the low-level mechanisms.  My biggest problem reading the
-article was for explanations of why a particular decision was taken,
-or why a particular mechanism may be used --- often this description
-is actually later in the article, but at that point it's too late for
-the reader.  I have tried to point out most of these places in the
-detailed comments below.
-My second concern is that the article makes several claims that are
-not really justified by the design or implementation in the article.
-These include claims that this approach meets the expectations of C
-programmers, is minimal, is implemented in itself, etc.  The article
-doesn't generally offer evidence to support these assertions (for many
-of them, that would require empirical studies of programmers, or at
-least corpus studies). The solution here is to talk about motivations
-for the design choices "we made these decisions hoping that C
-programmers would be comfortable" rather than claims of fact "C
-programmers are comfortable".  Again I attempt to point these out below.
-* abstract: needs to characterize the work top down, and not make
-  claims "features respect the expectations of C programmers" that
-  are not supported empirically.
-* p1 line 14 "integrated"
-* introduction needs to introduce the big ideas and scope of the
-  article, not define terms.  Some of the terms / distinctions are
-  non-standard (e.g. the distinction between "concurrency" and
-  "parallelism") and can be avoided by using more specific terms
-  (mutual exclusion, synchronization, parallel execution. etc).
-* to me this article introduces novel language features, not just an
-  API.  Similarly, it doesn't talk about any additions "to the
-  language translator" - i.e compiler changes! - rather about language
-  features.
-* section 2 lines 6-9 why buy this fight against object-orientation?
-  this article doesn't need to make this argument, but needs to do a
-  better job of it if it does (see other comments below)
-* sec 2.1 - are these the same as C++. IF so, say so, if not, say why
-  not.
-* 2.2 calling it a "with statement" was confusing, given that a with
-  clause can appear in a routine declaration with a shorthand syntax.
-* 2.3 again compare with C++ and Java (as well as Ada)
-* line 9 "as we will see in section 3"
-* 2.4 I really quite like this syntax for operators, destructors not
-  so much.
-* 2.5 and many places elsewhere. Always first describe the semantics
-  of your language constructs, then describe their properties, then
-  compare with e.g. related languages (mostly C++ & Java?).  E.g in
-  this case, something like:
-  "C-forall includes constructors, which are called to initialize
-  newly allocated objects, and constructors, which are called when
-  objects are deallocated. Constructors and destructors are written as
-  functions returning void, under the special names "?{}" for
-  constructors and "^{}" for destructors: constructors may be
-  overridden, but destructors may not be.  The semantics of C-forall's
-  constructors and destructors are essentially those of C++."
-  this problem repeats many times throughout the article and should be
-  fixed everywhere.
-* 2.6 again, first describe then properties then comparison.
-   in this case, compare e.g. with C++ templates, Java/Ada generics
-   etc.
-* why special case forward declarations? It's not 1970 any more.
-* what are traits?  structural interfaces (like Go interfaces) or
-  nominal bindings?
-* section 3 - lines 2-30, also making very specific global definitions
-  as in the introduction. The article does not need to take on this
-  fight either, rather make clear that this is the conceptual model in
-  C-forall. (If the article starts at the top and works down, that may
-  well follow anyway).
-* "in modern programming languages... unacceptable"; "in a
-  system-level language.. concurrent programs should be written with
-  high-level features" - again, no need to take on these fights.
-* 3.1 onwards; I found all this "building" up hard to follow.
-  also it's not clear a "minimal" API must separately support
-  coroutines, threads, fibres, etc
-* FIG 2B - where's the output?
-  syntax "sout | next(f1) | next(f2) | endl" nowhere explained
-    why not use C++s' << and >>
-* FIG 3 be clearer, earlier about the coroutine" constructor syntax
-** ensure all figures are placed *after* their first mention in the
-   text. consider interleaving smaller snippets of text rather than
-   just referring to large figures
-* sec 3.1 p7 etc,. need more context / comparison e.g. Python
-  generators etc.
-* FIGURE 4 is this right?  should there a constructor for Cons taking
-  a Prod?
-* sec 3.2 order of constructors depends on the language.  more
-  generally, if the article is going to make arguments against OO
-  (e.g. section 2) then the article needs to explain, in detail, why
-  e.g. coroutine, thread, etc *cannot* be classes / objects.
-* "type coroutine_t must be an abstract handle.. descriptor and is
-  stack are non-copyable" - too many assumptions in here (and other
-  similar passages) that are not really spelled out in detail.
-* p10 line 4 introduces "coroutine" keyword. needs to give its
-  semantics. also needs to introduce and define properties and compare
-  before all the examples using coroutines.
-* p10 again, trait semantics need to be better defined
-* 3.3 should be an introduction to this section. Note that section
-  titles are not part of the text of the article.
-* what's the difference between "coroutines" and "user threads" (and
-  "fibres?")
-* what's a "task type" or an "interface routine"  or "underlying
-  thread"
-* section 4 - "... meaningless". nope some semantics are possible
-  e.g. if there's a memory model.
-* whatare "call/return based languages"
-* p12 - what if a programmer wants to join e.g. "1st of N" or "1st 3 of N"
-  threads rather than all threads in order
-* 4.1 p12 13-25, again it's not clear where this is going.  presenting the model
-  top down may hopefully resolve this
-* section 4 should be merged e.g. into sec 3 (or 5)
-* section 5 p13 what's "routine" scope. "call/return paradigm"
-* thread/ coroutine declarations, traits etc, all look pretty close to
-  inheritance. why wouldn't inheritance work?
-* open/closed locks = free/acquired free locks?
-* testability?
-* p14 lines 14-20 I had trouble following this.  e.g/. what's the
-  difference between "a type that is a monitor" and "a type that looks
-  like a monitor"?  why?
-* line 39 - what's an "object-oriented monitor"?    Java?
-    there is no one OO model of such things.
-* line 47 significant asset - how do you know?
-* how could this e.g. build a reader/writer lock
-* *p15 what's the "bank account transfer problem"
-*p16 lines6-10  why? explain?
-*p17 semantics of arrays of conditions is unclear
-     given e.g. previous comments about arrays of mutexes.
-*p18 define "spurious wakeup"
-*p18 line 44 - "a number of approaches were examined"?  which
- approaches? examined by whom?  if this is a novel contribution, needs
- rather more there, and more comparison with related work
-* FIG 8 consider e.g. sequence diagrams rather than code to show these
-  cases
-* 6.2 p19 line 5 "similarly, monitor routines can be added at any
-  time" really?  I thought C-forall was compiled? there's a big
-  difference between "static" and "dynamic" inheritance. which is this
-  closer to?
-* line 25 "FIgure 9 (B) shows the monitor implementation"
-   I didn't understand this, especially not as an implementation.
-* section 6.6 - if the article is to make claims about completeness,
-  about supporting low and high level operations, then this must be
-  expanded to give enough detail to support that argument
-* "truest realization" huh?
-* section 7 should be merged into 6 or 8.
-  it's not clear if this is exploring rejected alternatives,
-  out outlining different features offered by C-forall, or what.
-* sec 7.2 how do the other threads in sections 5 & 6 relate to the
-  user threads, fibres, etc here;
-* sec 8.1 I found these sections hard to follow. how is a cluster a
-  "collection of threads and virtual processors... like a virtual
-  machine"? Where do the thread pools from 7.3 fit in?
-*  sec 8.3 is out of place, probably unneeded in the paper
-* section 9 dives straight into details with no overview.  Section 9
-  seems very detailed, and depends on assumptions or details that are
-  not in the article.
-* section 10 covers only microbenchmarks. are there any moderate sized
-  macrobenchmarks that can compare across the different systems?
-  (e.g the Erlang Ring?)
-* sec 11 claims that "the entire C-forall runtime system are written
-  in C-forall". The article doesn't
-* future work should precede conclusion, not follow it
-* the article should have a related work section (2-3 pages) comparing
-  the design overall with various competing designs (C++, Java, go,
-  Rust,...)
-To encourage accountability, I'm signing my reviews in 2018. For the record, I am James Noble, kjx@ecs.vuw.ac.nz.
-Reviewing: 3
-Comments to the Author
-This paper describes the design and implementation of coroutine- and thread-based concurrency in the C-for-all (I will write "C\/") system, a considerably extended form of the C language with many concurrency features.
-It first provides an overview of the non-concurrency-related aspects of the host language (references, operator overloading, generics, etc.), then addresses several technical issues around concurrency, including the multi-monitor design, bulk acquiring of locks (including deadlock-avoiding management of acquisition order), solutions to difficult scheduling problems around these, and implementation of monitors in the presence of separate compilation. It also presents empirical data showing the execution times of several microbenchmarks in comparison with other threaded concurrency systems, in support of the claim that the implementation is competitive with them.
-Overall the impression I gained is that this is a substantial system into which have gone much thought and effort.
-However, the present paper is not written so as to communicate sufficiently clearly the novel practices or experiences that emerged from that effort. This manifests itself in several ways.
-The system is described in general, rather than with a focus on novel insights or experiences. It was not until page 18 that I found a statement that hinted at a possible core contribution: "Supporting barging prevention as well as extending internal scheduling to multiple monitors is the main source of complexity in design and implementation of C\/ concurrency." Even then, it is unclear whether such challenges have already been surmounted in prior systems, or what other challenges the paper may also be covering. The most complete list of claims appears to be in the Conclusion (section 11; oddly not the last section), although not everything listed is a novel feature of the work (e.g. N:M threading models are an old idea). This presentation needs to be completely inverted, to focus from the outset on the claimed novel/noteworthy experiences that the work embodies.
-The text describing the system's motivation is unconvincing on one point: the claim that library support for threading in C is "far from widespread" (p5, footnote A). The pthreads library API is standardised, albeit not in the C language specification but rather in POSIX -- a widespread standard indeed. (With systems languages, even if the language does not define a feature, it of course does not follow that that feature is not available -- since such languages permit extension of their own runtime and/or toolchain.) Of course, the combination of C and pthreads does not provide close to the full complement of C\/-supported features, so it is easy to make a case for C\/'s targeted "gap in the market". But again, a presentation focused on novel aspects would bring this out and enable the reader to learn from the authors' efforts much more readily.
-Certain sections of the text read like a tutorial on concurrency... which is potentially valuable, but does not seem to belong here. For example, much effort is spent introducing the notions of "synchronization" and "mutual exclusion", including the whole of Section 4.2. Presently it is unclear how this content supports the findings/experiences that the paper is detailing.
-Similarly, section 8 reads mostly as a basic introduction to user versus kernel threading implementations (including hybrid models such as N:M scheduling), and appears superfluous to this paper. Mixed into this are details of C\/'s specific approach. These could instead be stated directly, with references to handle the unlikely case where the reader is unfamiliar.
-I also found the definitions of certain terms through the paper a bit non-standard, for unclear reasons. For example, why "condition lock" rather than the standard "condition variable" (if indeed that is what is intended)? To say that "synchronisation" is about "timing" strikes me as potentially confusing, since in truth synchronisation concerns only relative timing, i.e. ordering. (Even ordering is something of a derived concept -- since of course, most commonly, control over ordering is built atop synchronisation primitives, rather than being provided directly by them.)
-The empirical data presented is a reasonable start at characterising the implementation's performance. However, it currently suffers certain flaws.
-Firstly, it is not clear what is being claimed. The data cannot really be said to "verify the implementation" (section 10). Presumably the claim is that the system is competitive with other systems offering reasonably high-level concurrency constructs (Java monitors, Go channels, etc.) and/or on low-level facilities (mutexes, coroutines). A claim of this form, emphasising the latter, does eventually appear in the Conclusion, but it needs to be made explicitly during the presentation of the experiments. Shifting the focus towards higher-level features may be a better target, since this appears to be C\/'s main advance over pthreads and similar libraries.
-It appears some additional or alternative competitor systems might be a better match. For example, many green-thread or N:M libraries for C exist (libdill/libmill, Marcel, even GNU Pth). It would be instructive to compare with these.
-It would help greatly if the "functionally identical" benchmark code that was run on the competing systems were made available somewhere. Omitting it from the main text of the paper is understandable, since it would take too much space, but its details may still have a critical bearing on the results.
-In some cases it simply wasn't clear what is being compared. In Table 3, what are "FetchAdd + FetchSub"? I'm guessing this is some open-coded mutex using C++ atomics, but (unless I'm missing something) I cannot see an explanation in the text.
-The reports of variance (or, rather, standard deviation) are not always plausible. Is there really no observable variation in three of Table 3's cases? At the least, I would appreciate more detail on the measures taken to reduce run-time variance (e.g. disabling CPU throttling perhaps?).
-The text habitually asserts the benefits of C\/'s design without convincing argument. For example, in 2.1, do C\/'s references really reduce "syntactic noise"? I am sympathetic to the problem here, because many design trade-offs simply cannot be evaluated without very large-scale or long-term studies. However, the authors could easily refrain from extrapolating to a grand claim that cannot be substantiated. For example, instead of saying C\/ is "expressive" or "flexible" or "natural", or (say) that fork/join concurrency is "awkward and unnecessary" (p11), it would be preferable simply to give examples of the cases are captured well in the C\/ design (ideally together with any less favourable examples that illustrate the design trade-off in question) and let them speak for themselves.
-One thing I found confusing in the presentation of coroutines is that it elides the distinction between "coroutines" (i.e. their definitions) and activations thereof. It would be helpful to make this clearer, since at present this makes some claims/statements hard to understand. For example, much of 3.2 talks about "adding fields", which implies that a coroutine's activation state exists as fields in a structured object -- as, indeed, it does in C\/. This is non-obvious because in a more classical presentation of coroutines, their state would live not in "fields" but in local variables. Similarly, the text also talks about composition of "coroutines" as fields within other "coroutines", and so on, whereas if I understand correctly, these are also activations. (By later on in the text, the "C\/ style" of such constructs is clear, but not at first.)
-I was expecting a reference to Adya et al's 2002 Usenix ATC paper, on the topic of "fibers" and cooperative threading generally but also for its illustrative examples of stack ripping (maybe around "linearized code is the bane of device drivers", p7, which seems to be making a similar observation).
-Minor comments:
-The writing is rather patchy. It has many typos, and also some cases of "not meaning what is said", unclear allusions, etc.. The following is a non-exhaustive list.
-- p2 line 7: "C has a notion of objects" -- true, but this is not intended as "object" in anything like the same sense as "object-oriented", so raising it here is somewhere between confusing and meaningless.
-- lots of extraneous hyphenation e.g "inheritance-relationships", "critical-section", "mutual-exclusion", "shared-state" (as a general rule, only hyphenate noun phrases when making an adjective out of them)
-- p4 "impossible in most type systems" -- this is not a property of the "type system" as usually understood, merely the wider language design
-- p17: "release all acquired mutex types in the parameter list" should just say "release all acquired mutexes that are designated in the parameter list" (it is not "types" that are being released or acquired);
-- p19: "a class includes an exhaustive list of operations" -- except it is definitively *not* exhaustive, for the reasons given immediately afterwards. I do see the problem here, about separate compilation meaning that the space of functions using a particular type is not bounded at compile time, but that needs to be identified clearly as the problem. (Incidentally, one idea is that perhaps this mapping onto a dense space could be solved at link- or load-time, in preference to run-time indirection.)
-- p22: in 6.5, the significance of this design decision ("threads... are monitors") was still not clear to me.
-- p22: [user threads are] "the truest realization of concurrency" sounds like unnecessary editorializing (many systems can exist that can also encode all others, without necessarily giving one supremacy... e.g. actors can be used to encode shared-state concurrency).
-- p24: on line 19, the necessary feature is not "garbage collection" but precise pointer identification (which is distinct; not all GCs have it, and it has other applications besides GC)
-- p24: lines 32-39 are very dense and of unclear significance; an example, including code, would be much clearer.
-- p25: "current UNIX systems" seems to mean "Linux", so please say that or give the behaviour or some other modern Unix (I believe Solaris is somewhat different, and possibly the BSDs too). Also, in the explanation of signal dynamics, it would be useful to adopt the quotation's own terminology of "process-directed" signals. Presumably the "internal" thread-directed signals were generated using tgkill()? And presumably the timer expiry signal is left unblocked only on the thread (virtual processor) running the "simulation"? (Calling it a "simulation" is a bit odd, although I realise it is borrowing the concept of a discrete event queue.)

doc/proposals/vtable.md

-              r933f32f
+              r6a9d4b4
 ==================================
+This is an adaptation of the earlier virtual proposal, updating it with new
+ideas, re-framing it and laying out more design decisions. It should
+eventually replace the earlier proposal, but not all features and syntax have
+been converted to the new design.
 The basic concept of a virtual table (vtable) is the same here as in most
+other languages that use them. They will mostly contain function pointers
+although they should be able to store anything that goes into a trait.
+I also include notes on a sample implementation, which primarily exists to show
+there is a reasonable implementation. The code samples for that are in a slight
+pseudo-code to help avoid name mangling and keeps some CFA features while they
+would actually be written in C.
+other languages. They will mostly contain function pointers although they
+should be able to store anything that goes into a trait.
 Trait Instances
 …
 Currently traits are completely abstract. Data types might implement a trait
+but traits are not themselves data types. Which is to say you cannot have an
+instance of a trait. This proposal will change that and allow instances of
+traits to be created from instances of data types that implement the trait.
+For example:
+but traits are not themselves data types. This will change that and allow
+instances of traits to be created from instances of data types that implement
+the trait.
     trait combiner(otype T) {
         void combine(T&, int);
     };
+                void combine(T&, int);
+        };
     struct summation {
         int sum;
     };
+                int sum;
+        };
     void ?{}( struct summation & this ) {
         this.sum = 0;
+    }
+        void ?{}( struct summation & this ) {
+                this.sum = 0;
+        }
     void combine( struct summation & this, int num ) {
         this.sum = this.sum + num;
+    }
+                this.sum = this.sum + num;
+        }
     trait combiner obj = struct summation{};
     combine(obj, 5);
+        trait combiner obj = struct summation{};
+        combine(obj, 5);
 As with `struct` (and `union` and `enum`), `trait` might be optional when
 …
 before.
+For traits to be used this way they should meet two requirements. First they
+should only have a single polymorphic type and each assertion should use that
+type once as a parameter. Extensions may later loosen these requirements.
+Internally a trait object is a pair of pointers. One to an underlying object
+and the other to the vtable. All calls on an trait are implemented by looking
+up the matching function pointer and passing the underlying object and the
+remaining arguments to it.
+Also note this applies to the final expanded list of assertions. Consider:
+    trait foo(otype T, otype U) {
+        ... functions that use T once ...
+    }
+    trait bar(otype S | foo(S, char)) {
+        ... functions that use S once ...
+    }
+In this example `bar` may be used as a type but `foo` may not.
+When a trait is used as a type it creates a generic object which combines
+the base structure (an instance of `summation` in this case) and the vtable,
+which is currently created and provided by a hidden mechanism.
+The generic object type for each trait also implements that trait. This is
+actually the only means by which it can be used. The type of these functions
+look something like this:
+    void combine(trait combiner & this, int num);
+The main use case for trait objects is that they can be stored. They can be
+passed into functions, but using the trait directly is preferred in this case.
+    trait drawable(otype T) {
+        void draw(Surface & to, T & draw);
+        Rect(int) drawArea(T & draw);
+    };
+    struct UpdatingSurface {
+        Surface * surface;
+        vector(trait drawable) drawables;
+    };
+    void updateSurface(UpdatingSurface & us) {
+        for (size_t i = 0 ; i < us.drawables.size ; ++i) {
+            draw(us.surface, us.drawables[i]);
+        }
+    }
+With a more complete widget trait you could, for example, construct a UI tool
+kit that can declare containers that hold widgets without knowing about the
+widget types. Making it reasonable to extend the tool kit.
+The trait types can also be used in the types of assertions on traits as well.
+In this usage they passed as the underlying object and vtable pair as they
+are stored. The trait types can also be used in that trait's definition, which
+means you can pass two instances of a trait to a single function. However the
+look-up of the one that is not used to look up any functions, until another
+function that uses that object in the generic/look-up location is called.
+    trait example(otype T) {
+        bool test(T & this, trait example & that);
+    }
+### Explanation Of Restrictions
+The two restrictions on traits that can be used as trait objects are:
+.  Only one generic parameter may be defined in the trait's header.
+.  Each function assertion must have one parameter with the type of the
+    generic parameter. They may or may not return a value of that type.
+Elsewhere in this proposal I suggest ways to broaden these requirements.
+A simple example would be if a trait meets requirement 1 but not 2, then
+the assertions that do not satisfy the exactly one parameter requirement can
+be ignored.
+However I would like to talk about why these two rules are in place in the
+first place and the problems that any exceptions to these rules must avoid.
+The problems appear when the dispatcher function which operates on the
+generic object.
+    trait combiner(otype T, otype U) {
+        void combine(T&, U);
+    }
+This one is so strange I don't have proper syntax for it but let us say that
+the concrete dispatcher would be typed as
+`void combine(combiner(T) &, combiner(U));`. Does the function that combine
+the two underlying types exist to dispatch too?
+Maybe not. If `combiner(T)` works with ints and `combiner(U)` is a char then
+they could not be. It would have to enforce that all pairs of any types
+that are wrapped in this way. Which would pretty much destroy any chance of
+separate compilation.
+Even then it would be more expensive as the wrappers would have to carry ids
+that you use to look up on an <number of types>+1 dimensional table.
+The second restriction has a similar issue but makes a bit more sense to
+write out.
+    trait Series(otype T) {
+        ... size, iterators, getters ...
+        T join(T const &, T const &);
+    }
+With the dispatcher typed as:
+    Series join(Series const &, Series const &);
+Because these instances are generic and hide the underlying implementation we
+do not know what that implementation is. Unfortunately this also means the
+implementation for the two parameters might not be the same. Once we have
+two different types involved this devolves into the first case.
+We could check at run-time that the have the same underlying type, but this
+would likely time and space overhead and there is no clear recovery path.
+#### Sample Implementation
+A simple way to implement trait objects is by a pair of pointers. One to the
+underlying object and one to the vtable.
+    struct vtable_drawable {
+        void (*draw)(Surface &, void *);
+        Rect(int) (*drawArea)(void *);
+    };
+    struct drawable {
+        void * object;
+        vtable_drawable * vtable;
+    };
+The functions that run on the trait object would generally be generated using
+the following pattern:
+    void draw(Surface & surface, drawable & traitObj) {
+        return traitObj.vtable->draw(surface, traitObj.object);
+    }
+There may have to be special cases for things like copy construction, that
+might require a more significant wrapper. On the other hand moving could be
+implemented by moving the pointers without any need to refer to the base
+object.
+### Extension: Multiple Trait Parameters
+The base proposal in effect creates another use for the trait syntax that is
+related to the ones currently in the language but is also separate from them.
+The current uses generic functions and generic types, this new use could be
+described as generic objects.
+A generic object is of a concrete type and has concrete functions that work on
+it. It is generic in that it is a wrapper for an unknown type. Traits serve
+a similar role here as in generic functions as they limit what the function
+can be generic over.
+This combines the use allowing to have a generic type that is a generic
+object. All but one of the trait's parameters is given a concrete type,
+conceptually currying the trait to create a trait with on generic parameter
+that fits the original restrictions. The resulting concrete generic object
+type is different with each set of provided parameters and their values.
+Then it just becomes a question of where this is done. Again both examples use
+a basic syntax to show the idea.
+    trait iterator(virtual otype T, otype Item) {
+        bool has_next(T const &);
+        Item get_next(T const *);
+    }
+    iterator(int) int_it = begin(container_of_ints);
+The first option is to do it at the definition of the trait. One parameter
+is selected (here with the `virtual` keyword, but other rules like "the first"
+could also be used) and when an instance of the trait is created all the
+other parameters must be provided.
+    trait iterator(otype T, otype Item) {
+        bool has_next(T const &);
+        Item get_next(T const *);
+    }
+    iterator(virtual, int) int_it = begin(container_of_ints);
+The second option is to skip a parameter as part of the type instance
+definition. One parameter is explicitly skipped (again with the `virtual`
+keyword) and the others have concrete types. The skipped one is the one we
+are generic on.
+Incidentally in both examples `container_of_ints` may itself be a generic
+object and `begin` returns a generic iterator with unknown implementation.
+These options are not exclusive. Defining a default on the trait allows for
+an object to be created as in the first example. However, whether the
+default is provided or not, the second syntax can be used to pick a
+parameter on instantiation.
+Trait objects can be moved by moving the pointers. Almost all other operations
+require some functions to be implemented on the underlying type. Depending on
+what is in the virtual table a trait type could be a dtype or otype.
 Hierarchy
 ---------
+We would also like to implement hierarchical relations between types.
+Virtual tables by them selves are not quite enough to implement the planned
+hierarchy system. An addition of type ids, implemented as pointers which
+point to your parent's type id, is required to actually create the shape of
+the hierarchy. However vtables would allow behaviour to be carried with the
+tree.
+    ast_node
+    |-expression_node
+    | |-operator_expression
+    |
+    |-statement_node
+    | |-goto_statement
+    |
+    |-declaration_node
+      |-using_declaration
+      |-variable_declaration
+The hierarchy would be a tree of types, of traits and structs. Currently we do
+not support structural extension, so traits form the internal nodes and
+structures the leaf nodes.
+Virtual tables by themselves are not quite enough to implement this system.
+A vtable is just a list of functions and there is no way to check at run-time
+what these functions, we carry that knowledge with the table.
+The syntax is undecided but it will include a clause like `virtual (PARENT)`
+on trait and struct definitions. It marks out all types in a hierarchy.
+PARENT may be omitted, if it is this type is the root of a hierarchy. Otherwise
+it is the name of the type that is this type's parent in the hierarchy.
+This proposal adds type ids to check for position in the hierarchy and an
+explicate syntax for establishing a hierarchical relation between traits and
+their implementing types. The ids should uniquely identify each type and
+allow retrieval of the type's parent if one exists. By recursion this allows
+the ancestor relation between any two hierarchical types can be checked.
+Traits define a trait instance type that implements all assertions in this
+trait and its parents up until the root of the hierarchy. Each trait then
+defines a vtable type. Structures will also have a vtable type but it should
+be the same as their parent's.
+The hierarchy is created with traits as the internal nodes and structures
+as the leaf nodes. The structures may be used normally and the traits can
+be used to create generic objects as in the first section (the same
+restrictions apply). However these type objects store their type id which can
+be recovered to figure out which type they are or at least check to see if
+they fall into a given sub-tree at run-time.
+Trait objects within the tree can be statically cast to a parent type. Casts
+from a parent type to a child type are conditional, they check to make sure
+the underlying instance is an instance of the child type, or an instance of
+one of its children. The type then is recoverable at run-time.
+Here is an example of part of a hierarchy. The `virtual(PARENT)` syntax is
+just an example. But when used it give the name of the parent type or if
+empty it shows that this type is the root of its hierarchy.
+(Also I'm not sure where I got these casing rules.)
+As with regular trait objects, calling a function on a trait object will cause
+a look-up on the the virtual table. The casting rules make sure anything that
+can be cast to a trait type will have all the function implementations for
+that trait.
+    trait ast_node(otype T) virtual() {
+        void print(T & this, ostream & out);
+        void visit(T & this, Visitor & visitor);
+        CodeLocation const & get_code_location(T & this);
+    }
+Converting from a concrete type (structures at the edge of the hierarchy) to
+an abstract type works the same as with normal trait objects, the underlying
+object is packaged with a virtual table pointer. Converting back to an abstract
+type requires confirming the underlying type matches, but then simply extracts
+the pointer to it.
+    trait expression_node(otype T) virtual(ast_node) {
+        Type eval_type(T const & this);
+    }
+### Inline vtables
+Since the structures here are usually made to be turned into trait objects
+it might be worth it to have fields on them to store the virtual table
+pointer. This would have to be declared on the trait as an assertion, but if
+it is the trait object could be a single pointer.
+    struct operator_expression virtual(expression_node) {
+        enum operator_kind kind;
+        trait expression_node rands[2];
+    }
+    trait statement_node(otype T) virtual(ast_node) {
+        vector(Label) & get_labels(T & this);
+    }
+    struct goto_statement virtual(statement_node) {
+        vector(Label) labels;
+        Label target;
+    }
+    trait declaration_node(otype T) virtual(ast_node) {
+        string name_of(T const & this);
+        Type type_of(T const & this);
+    }
+    struct using_declaration virtual(declaration_node) {
+        string new_type;
+        Type old_type;
+    }
+    struct variable_declaration virtual(declaration_node) {
+        string name;
+        Type type;
+    }
+This system does not support multiple inheritance. The system could be
+extended to support it or a limited form (ex. you may have multiple parents
+but they may not have a common ancestor). However this proposal focuses just
+on using hierachy as organization. Other uses for reusable/genaric code or
+shared interfaces is left for other features of the language.
+### Extension: Structural Inheritance
+An extension would be allow structures to be used as internal nodes on the
+inheritance tree. Its child types would have to implement the same fields.
+The weaker restriction would be to convert the fields into field assertions
+(Not implemented yet: `U T.x` means there is a field of type you on the type
+T. Offset unknown and passed in/stored with function pointers.)
+A concrete child would have to declare the same set of fields with the same
+types. This is of a more functional style.
+The stronger restriction is that the fields of the parent are a prefix of the
+child's fields. Possibly automatically inserted. This the imperative view and
+may also have less overhead.
+### Extension: Unions and Enumerations
+Currently there is no reason unions and enumerations, in the cases they
+do implement the trait, could not be in the hierarchy as leaf nodes.
+It does not work with structural induction, but that could just be a compile
+time check that all ancestors are traits or do not add field assertions.
+#### Sample Implementation
+The type id may be as little as:
+    struct typeid {
+        struct typeid const * const parent;
+    };
+Some linker magic would have to be used to ensure exactly one copy of each
+structure for each type exists in memory. There seem to be special once
+sections that support this and it should be easier than generating unique
+ids across compilation units.
+The structure could be extended to contain any additional type information.
+There are two general designs for vtables with type ids. The first is to put
+the type id at the top of the vtable, this is the most compact and efficient
+solution but only works if we have exactly 1 vtable for each type. The second
+is to put a pointer to the type id in each vtable. This has more overhead but
+allows multiple vtables per type.
+    struct <trait>_vtable {
+        struct typeid const id;
+        // Trait dependent list of vtable members.
+    };
+    struct <trait>_vtable {
+        struct typeid const * const id;
+        // Trait dependent list of vtable members.
+    };
+One important restriction is that only one instance of each typeid in memory.
+There is a ".gnu.linkonce" feature in the linker that might solve the issue.
+### Virtual Casts
+The generic objects may be cast up and down the hierarchy.
+Casting to an ancestor type always succeeds. From one generic type to another
+is just a reinterpretation and could be implicate. Wrapping and unwrapping
+a concrete type will probably use the same syntax as in the first section.
+Casting from an ancestor to a descendent requires a check. The underlying
+type may or may not belong to the sub-tree headed by that descendent. For this
+we introduce a new cast operator, which returns the pointer unchanged if the
+check succeeds and null otherwise.
+    trait SubType * new_value = (virtual trait SubType *)super_type;
+For the following example I am using the as of yet finished exception system.
+    trait exception(otype T) virtual() {
+        char const * what(T & this);
+    }
+    trait io_error(otype T) virtual(exception) {
+        FILE * which_file(T & this);
+    }
+    struct eof_error(otype T) virtual(io_error) {
+        FILE * file;
+    }
+    char const * what(eof_error &) {
+        return "Tried to read from an empty file.";
+    }
+    FILE * which_file(eof_error & this) {
+        return eof_error.file;
+    }
+    bool handleIoError(exception * exc) {
+        io_error * error = (virtual io_error *)exc;
+        if (NULL == error) {
+            return false;
+        }
+        ...
+        return true;
+    }
+### Extension: Implicate Virtual Cast Target
+This is a small extension, even in the example above `io_error *` is repeated
+in the cast and the variable being assigned to. Using return type inference
+would allow the second type to be skipped in cases it is clear what type is
+being checked against.
+The line then becomes:
+    io_error * error = (virtual)exc;
+#### Sample Implementation
+This cast implementation assumes a type id layout similar to the one given
+above. Also this code is definitely in the underlying C. Functions that give
+this functionality could exist in the standard library but these are meant to
+be produced by code translation of the virtual cast.
+    bool is_in_subtree(typeid const * root, typeid const * id) {
+        if (root == id) {
+            return true
+        } else if (NULL == id->parent) {
+            return false;
+        } else {
+            return is_in_subtree(root, id->parent);
+        }
+    }
+    void * virtual_cast(typeid const * target, void * value) {
+        return is_in_subtree(target, *(typeid const **)value) ? value : NULL;
+    }
+The virtual cast function might have to be wrapped with some casts to make it
+compile without warning.
+For the implicate target type we may be able to lean on the type resolution
+system that already exists. If the casting to ancestor type is built into
+the resolution then the impicate target could be decided by picking an
+overload, generated for each hierarchial type (here io_error and its root
+type exception).
+    io_error * virtual_cast(exception * value) {
+        return virtual_cast(io_error_typeid, value);
+    }
+### Extension: Inline vtables
+Since the structures here are usually made to be turned into trait objects
+it might be worth it to have fields in them to store the virtual table
+pointer. This would have to be declared on the trait as an assertion (example:
+`vtable;` or `T.vtable;`), but if it is the trait object could be a single
+pointer.
+There are also three options for where the pointer to the vtable. It could be
+anywhere, a fixed location for each trait or always at the front. For the per-
+trait solution an extension to specify what it is (example `vtable[0];`) which
+could also be used to combine it with others. So these options can be combined
+to allow access to all three options.
+The pointer to virtual table field on structures might implicately added (the
+types have to declare they are a child here) or created with a declaration,
+possibly like the one used to create the assertion.
+It is trivial to do if the field with the virtual table pointer is fixed.
+Otherwise some trickery with pointing to the field and storing the offset in
+the virtual table to recover the main object would have to be used.
 ### Virtual Tables as Types
+Here we consider encoding plus the implementation of functions on it to be a
+type. Which is to say in the type hierarchy structures aren't concrete types
+anymore, instead they are parent types to vtables, which combine the encoding
+and implementation.
+### Question: Wrapping Structures
+One issue is what to do with concrete types at the base of the type tree.
+When we are working with the concrete type generally it would like them to be
+regular structures with direct calls. On the other hand for interactions with
+other types in the hierarchy it is more convenent for the type already to be
+cast.
+Which of these two should we use? Should we support both and if so how do we
+choose which one is being used at any given time.
+On a related note I have been using pointers two trait types here, as that
+is how many existing languages handle it. However the generic objects might
+be only one or two pointers wide passing the objects as a whole would not
+be very expensive and all operations on the generic objects probably have
+to be defined anyways.
+Here we consider encoding plus the implementation of functions on it. Which
+is to say in the type hierarchy structures aren't concrete types anymore,
+instead they are parent types to vtables, which combine the encoding and
+implementation.
 Resolution Scope
 …
 the type declaration, including the functions that satisfy the trait, are
 all defined. Currently there are many points where this can happen, not all
+of them have the same definitions and no way to select one over the other.
+of them will have the same definitions and no way to select one over the
+other.
+Some syntax would have to be added to specify the resolution point. To ensure
+a single instance there may have to be two variants, one forward declaration
+and one to create the instance. With some compiler magic the forward
+declaration maybe enough.
+    extern trait combiner(struct summation) vtable;
+    trait combiner(struct summation) vtable;
+Or (with the same variants):
+    vtable combiner(struct summation);
+The extern variant promises that the vtable will exist while the normal one
+is where the resolution actually happens.
+Some syntax would have to be added. All resolutions can be found at compile
+time and a single vtable created for each type at compilation time.
 ### Explicit Resolution Points:
 …
 However this also means that stack-allocated functions can end up in the
 vtable.
-    extern trait combiner(struct summation) vtable sum;
-    trait combiner(struct summation) vtable sum;
-    extern trait combiner(struct summation) vtable sum default;
-    trait combiner(struct summation) vtable sum default;
-The extern difference is the same before. The name (sum in the samples) is
-used at the binding site to say which one is picked. The default keyword can
-be used in only some of the declarations.
-    trait combiner fee = (summation_instance, sum);
-    trait combiner foe = summation_instance;
-(I am not really happy about this syntax, but it kind of works.)
-The object being bound is required. The name of the vtable is optional if
-there is exactly one vtable name marked with default.
-These could also be placed inside functions. In which case both the name and
-the default keyword might be optional. If the name is omitted in an assignment
-the closest vtable is chosen (returning to the global default rule if no
-appropriate local vtable is in scope).
 ### Site Based Resolution:
 …
 Stack allocated functions interact badly with this because they are not
 static. There are several ways to try to resolve this, however without a
+general solution most can keep vtables from making the existing thunk problem
+worse, they don't do anything to solve it.
+general solution most can only buy time.
 Filling in some fields of a static vtable could cause issues on a recursive
 …
 shortest lifetime of a function assigned to it. However this still limits the
 lifetime "implicitly" and returns to the original problem with thunks.
-Odds And Ends
--------------
-In addition to the main design there are a few extras that should be
-considered. They are not part of the core design but make the new uses fully
-featured.
-### Extension: Parent-Child Assertion
-For hierarchy types in regular traits, generic functions or generic structures
-we may want to be able to check parent-child relationships between two types
-given. For this we might have to add another primitive assertion. It would
-have the following form if declared in code:
-    trait is_parent_child(dtype Parent, dtype Child) { <built-in magic> }
-This assertion is satified if Parent is an ancestor of Child in a hierarchy.
-In other words Child can be statically cast to Parent. The cast from Parent
-to child would be dynamically checked as usual.
-However in this form there are two concerns. The first that Parent will
-usually be consistent for a given use, it will not be a variable. Second is
-that we may also need the assertion functions. To do any casting/conversions
-anyways.
-TODO: Talk about when we wrap a concrete type and how that leads to "may".
-To this end it may be better that the parent trait combines the usual
-assertions plus this new primitive assertion. There may or may not be use
-cases for accessing just one half and providing easy access to them may be
-required depending on how that turns out.
-    trait Parent(dtype T | interface(T)) virtual(<grand-parent?>) { }
-### Extension: sizeof Compatablity
-Trait types are always sized, it may even be a fixed size like how pointers
-have the same size regardless of what they point at. However their contents
-may or may not be of a known size (if the `sized(...)` assertion is used).
-Currently there is no way to access this information. If it is needed a
-special syntax would have to be added. Here a special case of `sizeof` is
-used.
-    struct line aLine;
-    trait drawable widget = aLine;
-    size_t x = sizeof(widget);
-    size_t y = sizeof(trait drawable);
-As usual `y`, size of the type, is the size of the local storage used to put
-the value into. The other case `x` checks the saved stored value in the
-virtual table and returns that.

doc/theses/aaron_moss_PhD/phd/Makefile

-              r933f32f
+              r6a9d4b4
 BIBDIR = ../../../bibliography
 EVALDIR = evaluation
-FIGDIR = figures
 TEXLIB = .:${BUILD}:${BIBDIR}:
 …
 BIBTEX = BIBINPUTS=${TEXLIB} && export BIBINPUTS && bibtex
 VPATH = ${EVALDIR} ${FIGDIR}
+VPATH = ${EVALDIR}
 BASE = thesis
 …
 background \
 generic-types \
+type-environment \
 resolution-heuristics \
-type-environment \
-experiments \
 conclusion \
-generic-bench \
+}
-FIGURES = ${addsuffix .eps, \
-safe-conv-graph \
-resolution-dag \
-union-find-with-classes \
-persistent-union-find \
+}
 GRAPHS = ${addsuffix .tex, \
 generic-timing \
-tests-completed \
-per-prob-histo \
-per-prob-depth \
-cfa-time \
+}
 …
         dvips ${BUILD}/$< -o ${BUILD}/$@
 ${BASE}.dvi : Makefile ${SOURCES} ${GRAPHS} ${FIGURES} ${BIBFILE} ${BUILD}
+${BASE}.dvi : Makefile ${SOURCES} ${GRAPHS} ${BIBFILE} ${BUILD}
         ${LATEX} ${BASE}
         ${BIBTEX} ${BUILD}/${BASE}
 …
         ${LATEX} ${BASE}
 generic-timing.tex : generic-timing.gp generic-timing.dat ${BUILD}
+${GRAPHS} : generic-timing.gp generic-timing.dat ${BUILD}
         gnuplot -e BUILD="'${BUILD}/'" ${EVALDIR}/generic-timing.gp
-tests-completed.tex : algo-summary.gp algo-summary.dat bu-summary.dat ${BUILD}
-        gnuplot -e BUILD="'${BUILD}/'" ${EVALDIR}/algo-summary.gp
-per-prob-histo.tex : per-prob.gp per-prob.tsv ${BUILD}
-        gnuplot -e BUILD="'${BUILD}/'" ${EVALDIR}/per-prob.gp
-per-prob-depth.tex : per-prob-scatter.gp ${BUILD}
-        gnuplot -e BUILD="'${BUILD}/'" ${EVALDIR}/per-prob-scatter.gp
-cfa-time.tex : cfa-plots.gp cfa-time.tsv cfa-mem.tsv ${BUILD}
-        gnuplot -e BUILD="'${BUILD}/'" ${EVALDIR}/cfa-plots.gp
 ${BUILD}:

doc/theses/aaron_moss_PhD/phd/background.tex

-              r933f32f
+              r6a9d4b4
 \chapter{\CFA{}}
-\label{cfa-chap}
 \CFA{} adds a number of features to C, some of them providing significant increases to the expressive power of the language, but all designed to maintain the existing procedural programming paradigm of C and to be as orthogonal as possible to each other.
 To provide background for the contributions in subsequent chapters, this chapter provides a summary of the features of \CFA{} at the time this work was conducted.
+Glen Ditchfield laid out the core design of \CFA{} in his 1992 PhD thesis, \emph{Contextual Polymorphism} \cite{Ditchfield92}; in that thesis, Ditchfield presents the theoretical underpinnings of the \CFA{} polymorphism model.
+Building on Ditchfield's design for contextual polymorphism as well as KW-C \cite{Buhr94a}, an earlier set of (largely syntactic) extensions to C, Richard Bilson \cite{Bilson03} built the first version of the \CFA{} compiler, \CFACC{}, in the early 2000's.
+This early \CFACC{} provided basic functionality, but incorporated a number of algorithmic choices that have failed to scale as \CFA{} has developed, lacking the runtime performance for practical use; this thesis is substantially concerned with rectifying those deficits.
+The \CFA{} project was revived in 2015 with the intention of building a production-ready language and compiler; at the time of this writing, both \CFA{} and \CFACC{} remain under active development.
+As this development has been proceeding concurrently with the work described in this thesis, the state of \CFA{} has been somewhat of a moving target; however, Moss~\etal~\cite{Moss18} provides a reasonable summary of the current design.
+Notable features added during this period include generic types (Chapter~\ref{generic-chap}), constructors and destructors \cite{Schluntz17}, improved support for tuples \cite{Schluntz17}, reference types \cite{Moss18}, first-class concurrent and parallel programming support \cite{Delisle18}, as well as numerous pieces of syntactic sugar and the start of an idiomatic standard library \cite{Moss18}.
+This thesis is primarily concerned with the \emph{expression resolution} portion of \CFA{} type-checking; resolution is discussed in more detail in Chapter~\ref{resolution-chap}, but is essentially determining which declarations the identifiers in each expression correspond to.
+In C, no simultaneously-visible declarations share identifiers, hence expression resolution in C is not difficult.
+In \CFA{}, multiple added features make the resolution process significantly more complex.
+Due to this complexity, the expression-resolution pass in \CFACC{} requires 95\% of compiler runtime on some source files, making a new, more efficient procedure for expression resolution a requirement for a performant \CFA{} compiler.
+The features presented in this chapter are chosen to elucidate the design constraints of the work presented in this thesis.
+In some cases the interactions of multiple features make this design a significantly more complex problem than any individual feature; in other cases a feature that does not by itself add any complexity to expression resolution triggers previously rare edge cases more frequently.
+\section{Procedural Paradigm}
+The core design of \CFA{} is laid out in Glen Ditchfield's 1992 PhD thesis, \emph{Contextual Polymorphism}\cite{Ditchfield92}; in that thesis, Ditchfield presents the theoretical underpinnings of the \CFA{} polymorphism model.
+Building on Ditchfield's design for contextual polymorphism as well as KW-C\cite{Buhr94a}, an earlier set of (largely syntactic) extensions to C, Richard Bilson\cite{Bilson03} built the first version of the \CFA{} compiler, \CFACC{}, in the early 2000's.
+This early \CFACC{} provided basic functionality, but incorporated a number of poor algorithmic choices due to a rushed implementation time frame, and as such lacked the runtime performance required for practical use; this thesis is substantially concerned with rectifying those deficits.
+The \CFA{} project was revived in 2015 with the intention of building a production-ready language and compiler; at the time of this writing, both \CFA{} and \CFACC{} have been under active development continuously since.
+As this development has been proceeding concurrently with the work described in this thesis, the state of \CFA{} has been somewhat of a moving target; however, Moss~\etal\cite{Moss18} provides a reasonable summary of the current design.
+Notable features added during this period include generic types (Chapter~\ref{generic-chap}), constructors and destructors\cite{Schluntz17}, improved support for tuples\cite{Schluntz17}, reference types\cite{Moss18}, first-class concurrent and parallel programming support\cite{Delisle18}, as well as numerous pieces of syntactic sugar and the start of an idiomatic standard library\cite{Moss18}.
+\section{\CFA{} Features}
+The selection of features presented in this chapter are chosen to elucidate the design constraints of the work presented in this thesis.
+In some cases the interactions of multiple features make this design a significantly more complex problem than any individual feature would; in other cases a feature that does not by itself add any complexity to expression resolution triggers previously rare edge cases more frequently.
+\subsection{Procedural Paradigm}
 It is important to note that \CFA{} is not an object-oriented language.
+This is a deliberate choice intended to maintain the applicability of the programming model and language idioms already possessed by C programmers.
+This choice is in marked contrast to \CC{}, which is a much larger and more complex language, and requires extensive developer re-training to write idiomatic, efficient code in \CC{}'s object-oriented paradigm.
+This is a deliberate choice intended to maintain the applicability of the mental model and language idioms already possessed by C programmers.
+This choice is in marked contrast to \CC{}, which, though it has backward-compatibility with C on the source code level, is a much larger and more complex language, and requires extensive developer re-training to write idiomatic, efficient code in \CC{}'s object-oriented paradigm.
+\CFA{} does have a system of implicit type conversions derived from C's ``usual arithmetic conversions''; while these conversions may be thought of as something like an inheritance hierarchy, the underlying semantics are significantly different and such an analogy is loose at best.
 Particularly, \CFA{} has no concept of \emph{subclass}, and thus no need to integrate an inheritance-based form of polymorphism with its parametric and overloading-based polymorphism.
+While \CFA{} does have a system of implicit type conversions derived from C's ``usual arithmetic conversions'' \cite[\S{}6.3.1.8]{C11} and these conversions may be thought of as something like an inheritance hierarchy, the underlying semantics are significantly different and such an analogy is loose at best.
+The graph structure of the \CFA{} type conversions (discussed in Section~\ref{conv-cost-sec}) is also markedly different than an inheritance hierarchy; it has neither a top nor a bottom type, and does not satisfy the lattice properties typical of inheritance hierarchies.
+The graph structure of the \CFA{} type conversions is also markedly different than an inheritance hierarchy; it has neither a top nor a bottom type, and does not satisfy the lattice properties typical of inheritance hierarchies.
 Another aspect of \CFA{}'s procedural paradigm is that it retains C's translation-unit-based encapsulation model, rather than class-based encapsulation such as in \CC{}.
+As such, any language feature that requires code to be exposed in header files (\eg{} \CC{} templates) also eliminates encapsulation in \CFA{}.
+Given this constraint, \CFA{} is carefully designed to allow separate compilation for its added language features under the existing C usage patterns.
+\section{Name Overloading} \label{overloading-sec}
+In C, no more than one variable or function in the same scope may share the same name\footnote{Technically, C has multiple separated namespaces, one holding \lstinline{struct}, \lstinline{union}, and \lstinline{enum} tags, one holding labels, one holding \lstinline{typedef} names, variable, function, and enumerator identifiers, and one for each \lstinline{struct} and \lstinline{union} type holding the field names \cite[\S{}6.2.3]{C11}.}, and variable or function declarations in inner scopes with the same name as a declaration in an outer scope hide the outer declaration.
+This restriction makes finding the proper declaration to match to a variable expression or function application a simple matter of lexically-scoped name lookup, which can be easily and efficiently implemented.
+This choice implies that that separate compilation must be maintained to allow headers to act as an encapsulation boundary, rather than the header-only libraries used by \CC{} templates.
+\subsection{Name Overloading} \label{overloading-sec}
+In C, no more than one variable or function in the same scope may share the same name\footnote{Technically, C has multiple separated namespaces, one holding \lstinline{struct}, \lstinline{union}, and \lstinline{enum} tags, one holding labels, one holding \lstinline{typedef} names, variable, function, and enumerator identifiers, and one for each \lstinline{struct} and \lstinline{union} type holding the field names\cit{}.}, and variable or function declarations in inner scopes with the same name as a declaration in an outer scope hide the outer declaration.
+This restriction makes finding the proper declaration to match to a variable expression or function application a simple matter of symbol-table lookup, which can be easily and efficiently implemented.
 \CFA{}, on the other hand, allows overloading of variable and function names so long as the overloaded declarations do not have the same type, avoiding the multiplication of variable and function names for different types common in the C standard library, as in the following example:
 …
 \end{cfa}
+The final expression in the preceding example includes a feature of \CFA{} name overloading not shared by \CC{}, the ability to disambiguate expressions based on their return type. This provides greater flexibility and power than the parameter-based overload selection of \CC{}, though at the cost of greater complexity in the resolution algorithm.
+While the wisdom of giving both the maximum value of a type and the function to take the maximum of two values the same name in the example above is debatable, \eg{} some developers may prefer !MAX! for the former, the guiding philosophy of \CFA{} is ``describe, don't prescribe'' --- we prefer to trust programmers with powerful tools, and there is no technical reason to restrict overloading between variables and functions.
+However, the expressivity of \CFA{}'s name overloading does have the consequence that simple table lookup is insufficient to match identifiers to declarations, and a type-matching algorithm must be part of expression resolution.
+\subsection{Operator Overloading}
+While the wisdom of giving both the maximum value of a type and the function to take the maximum of two values the same name is debatable, \eg{} some developers may prefer !MAX! for the former, the guiding philosophy of \CFA{} is ``describe, don't prescribe'' --- we prefer to trust programmers with powerful tools, and there is no technical reason to restrict overloading between variables and functions.
+However, the expressivity of \CFA{}'s name overloading has the consequence that simple table lookup is insufficient to match identifiers to declarations, and a type-matching algorithm must be part of expression resolution.
+\subsubsection{Operator Overloading}
 C does allow name overloading in one context: operator overloading.
 From the perspective of the type system, there is nothing special about operators as opposed to other functions, nor is it desirable to restrict the clear and readable syntax of operators to only the built-in types.
+For these reasons, \CFA{}, like \CC{} and many other programming languages, allows overloading of operators by writing specially-named functions where !?! stands in for the operands.
+This syntax is more natural than the operator overloading syntax of \CC{}, which requires ``dummy'' parameters to disambiguate overloads of similarly-named pre- and postfix operators\footnote{This example uses \CFA{}'s reference types, described in Section~\ref{type-features-sec}}:
+For these reasons, \CFA{} also allows overloading of operators by writing specially-named functions where !?! stands in for the operands\footnote{This example uses \CFA{}'s reference types, described in Section~\ref{type-features-sec}}:
 \begin{cfa}
 …
 \end{cfa}
 Together, \CFA{}'s backward-compatibility with C and the inclusion of this operator overloading feature imply that \CFA{} must select among function overloads using a method compatible with C's ``usual arithmetic conversions'' \cite[\S{}6.3.1.8]{C11}, so as to present user programmers with only a single set of overloading rules.
 \subsection{Special Literal Types}
+Together, \CFA{}'s backward-compatibility with C and the inclusion of this operator overloading feature imply that \CFA{} must select among function overloads using a method compatible with C's ``usual arithmetic conversions''\cit{}, so as to present user programmers with only a single set of overloading rules.
+\subsubsection{Special Literal Types}
 Literal !0! is also used polymorphically in C; it may be either integer zero or the null value of any pointer type.
+\CFA{} provides a special type for the !0! literal, !zero_t!, so that users can define a zero value for their own types without being forced to create a conversion from an integer or pointer type; \CFA{} also includes implicit conversions from !zero_t! to the !int! and pointer type constructors\footnote{See Section~\ref{type-features-sec}} from !zero_t! for backward compatibility.
+According to the C standard \cite[\S{}6.8.4.1]{C11}, !0! is the only false value; any value that compares equal to zero is false, while any value that does not is true.
+By this rule, Boolean contexts such as !if ( x )! can always be equivalently rewritten as \lstinline{if ( (x) != 0 )}.
+\CFACC{} applies this rewriting in all Boolean contexts, so any type !T! can be made ``truthy'' (that is, given a Boolean interpretation) in \CFA{} by defining an operator overload \lstinline{int ?!=?(T, zero_t)}.
+\CC{} takes a different approach to user-defined truthy types, allowing definition of an implicit conversion operator to !bool!; prior to the introduction of the !explicit! keyword for conversion operators in \CCeleven{} this approach also allowed undesired implicit conversions to all other arithmetic types, a shortcoming not shared by the \CFA{} design.
+\CFA{} provides a special type for the !0! literal, !zero_t!, so that users can define a zero value for their own types without being forced to create a conversion from an integer or pointer type (though \CFA{} also includes implicit conversions from !zero_t! to the integer and pointer types for backward compatibility).
+According to the C standard\cit{}, !0! is the only false value; any value that compares equal to zero is false, while any value that does not is true.
+By this rule, boolean contexts such as !if ( x )! can always be equivalently rewritten as \lstinline{if ( (x) != 0 )}.
+\CFACC{} applies this rewriting in all boolean contexts, so any type !T! can be made ``truthy'' (that is, given a boolean interpretation) in \CFA{} by defining an operator overload \lstinline{int ?!=?(T, zero_t)}; unlike \CC{} prior to the addition of explicit casts in \CCeleven{}, this design does not add comparability or convertablity to arbitrary integer types.
 \CFA{} also includes a special type for !1!, !one_t!; like !zero_t!, !one_t! has built-in implicit conversions to the various integral types so that !1! maintains its expected semantics in legacy code.
 The addition of !one_t! allows generic algorithms to handle the unit value uniformly for types where it is meaningful; a simple example of this is that polymorphic functions\footnote{discussed in Section~\ref{poly-func-sec}} in the \CFA{} prelude define !++x! and !x++! in terms of !x += 1!, allowing users to idiomatically define all forms of increment for a type !T! by defining the single function !T& ?+=?(T&, one_t)!; analogous overloads for the decrement operators are also present, and programmers can override any of these functions for a particular type if desired.
 \CFA{} previously allowed !0! and !1! to be the names of polymorphic variables, with separate overloads for !int 0!, !int 1!, and the polymorphic variable !forall(dtype T) T* 0!.
 While designing \CFA{} generic types (see Chapter~\ref{generic-chap}), it was discovered that the parametric polymorphic zero variable is not generalizable to other types; though all null pointers have the same in-memory representation, the same cannot be said of the zero values of arbitrary types.
 As such, polymorphic variables, and in particular variables for !0! and !1!, were phased out in favour of functions that could generate those values for a given type as appropriate.
 \section{Polymorphic Functions} \label{poly-func-sec}
 The most significant type-system feature \CFA{} adds is parametric-polymorphic functions.
+\CFA{} previously allowed !0! and !1! to be the names of polymorphic variables, with separate overloads for !int 0!, !int 1!, and !forall(dtype T) T* 0!.
+As revealed in my own work on generic types (Chapter~\ref{generic-chap}), the parameteric polymorphic zero variable was not generalizable to other types; though all null pointers have the same in-memory representation, the same cannot be said of the zero values of arbitrary types.
+As such, variables that could represent !0! and !1! were phased out in favour of functions that could generate those values for a given type as appropriate.
+\subsection{Polymorphic Functions} \label{poly-func-sec}
+The most significant feature \CFA{} adds is parametric-polymorphic functions.
 Such functions are written using a !forall! clause (which gives the language its name):
 …
 The type variable !T! is transformed into a set of additional implicit parameters to !identity!, which encode sufficient information about !T! to create and return a variable of that type.
 \CFA{} passes the size and alignment of the type represented by an !otype! parameter, as well as a default constructor, copy constructor, assignment operator, and destructor.
+Types that do not have one or more of these operators visible cannot be bound to !otype! parameters, but may be bound to un-constrained !dtype! (``data type'') type variables.
+In this design, the runtime cost of polymorphism is spread over each polymorphic call, due to passing more arguments to polymorphic functions; the experiments in Chapter~\ref{generic-chap} indicate that this overhead is comparable to that of \CC{} virtual function calls.
+% \TODO{rerun experiments, possibly look at vtable variant}
+Types which do not have one or more of these operators visible cannot be bound to !otype! parameters.
+In this design, the runtime cost of polymorphism is spread over each polymorphic call, due to passing more arguments to polymorphic functions; experiments have shown this overhead to be similar to \CC{} virtual function calls. \TODO{rerun experiments, possibly look at vtable variant}
 One benefit of this design is that it allows polymorphic functions to be separately compiled.
 …
 The fact that there is only one implementation of each polymorphic function also reduces compile times relative to the template-expansion approach taken by \CC{}, as well as reducing binary sizes and runtime pressure on instruction cache by re-using a single version of each function.
 \subsection{Type Assertions}
 Since bare polymorphic types do not provide a great range of available operations, \CFA{} provides a \emph{type assertion} mechanism to provide further information about a type\footnote{This example introduces a convention used throughout this thesis of disambiguating overloaded names with subscripts; the subscripts do not appear in \CFA{} source code.}:
+\subsubsection{Type Assertions}
+Since bare polymorphic types do not provide a great range of available operations, \CFA{} provides a \emph{type assertion} mechanism to provide further information about a type:
 \begin{cfa}
 forall(otype T `| { T twice(T); }`)
 T four_times(T x) { return twice( twice(x) ); }
 double twice$\(_1\)$(double d) { return d * 2.0; }
+double twice(double d) { return d * 2.0; }  $\C[2.75in]{// (1)}$
 double ans = four_times( 10.5 );  $\C[2.75in]{// T bound to double, ans == 42.0}$
 …
 \begin{cfa}
 forall(otype S | { S ?+?(S, S); })
+S twice$\(_2\)$(S x) { return x + x; }
+\end{cfa}
+Specializing this polymorphic function with !S = double! produces a monomorphic function which can be used to satisfy the type assertion on !four_times!.
+\CFACC{} accomplishes this by creating a wrapper function calling !twice!$_2$ with !S! bound to !double!, then providing this wrapper function to !four_times!\footnote{\lstinline{twice}$_2$ could also have had a type parameter named \lstinline{T}; \CFA{} specifies renaming of the type parameters, which would avoid the name conflict with the type variable \lstinline{T} of \lstinline{four_times}}.
+However, !twice!$_2$ also works for any type !S! that has an addition operator defined for it.
+Finding appropriate functions to satisfy type assertions is essentially a recursive case of expression resolution, as it takes a name (that of the type assertion) and attempts to match it to a suitable declaration in the current scope\footnote{\CFACC{} actually performs a type-unification computation for assertion satisfaction rather than an expression resolution computation; see Section~\ref{assn-sat-sec} for details.}.
+S twice(S x) { return x + x; }  $\C[2.75in]{// (2)}
+\end{cfa}
+This version of !twice! works for any type !S! that has an addition operator defined for it, and it could be used to satisfy the type assertion on !four_times!.
+\CFACC{} accomplishes this by creating a wrapper function calling !twice//(2)! with !S! bound to !double!, then providing this wrapper function to !four_times!\footnote{\lstinline{twice // (2)} could also have had a type parameter named \lstinline{T}; \CFA{} specifies renaming of the type parameters, which would avoid the name conflict with the type variable \lstinline{T} of \lstinline{four_times}}.
+Finding appropriate functions to satisfy type assertions is essentially a recursive case of expression resolution, as it takes a name (that of the type assertion) and attempts to match it to a suitable declaration in the current scope.
 If a polymorphic function can be used to satisfy one of its own type assertions, this recursion may not terminate, as it is possible that that function is examined as a candidate for its own assertion unboundedly repeatedly.
+To avoid such infinite loops, \CFACC{} imposes a fixed limit on the possible depth of recursion, similar to that employed by most \CC{} compilers for template expansion; this restriction means that there are some otherwise semantically well-typed expressions that cannot be resolved by \CFACC{}.
+\subsection{Traits}
+\CFA{} provides \emph{traits} as a means to name a group of type assertions, as in the example below\footnote{This example uses \CFA{}'s reference types and constructors, described in Section~\ref{type-features-sec}.}:
+To avoid such infinite loops, \CFACC{} imposes a fixed limit on the possible depth of recursion, similar to that employed by most \CC{} compilers for template expansion; this restriction means that there are some semantically well-typed expressions that cannot be resolved by \CFACC{}.
+\TODO{Update this with final state} One contribution made in the course of this thesis was modifying \CFACC{} to use the more flexible expression resolution algorithm for assertion matching, rather than the simpler but limited previous approach of unification on the types of the functions.
+\subsubsection{Deleted Declarations}
+Particular type combinations can be exempted from matching a given polymorphic function through use of a \emph{deleted function declaration}:
+\begin{cfa}
+int somefn(char) = void;
+\end{cfa}
+This feature is based on a \CCeleven{} feature typically used to make a type non-copyable by deleting its copy constructor and assignment operator\footnote{In previous versions of \CC{}, a type could be made non-copyable by declaring a private copy constructor and assignment operator, but not defining either. This idiom is well-known, but depends on some rather subtle and \CC{}-specific rules about private members and implicitly-generated functions; the deleted function form is both clearer and less verbose.} or forbidding some interpretations of a polymorphic function by specifically deleting the forbidden overloads\footnote{Specific polymorphic function overloads can also be forbidden in previous \CC{} versions through use of template metaprogramming techniques, though this advanced usage is beyond the skills of many programmers. A similar effect can be produced on an ad-hoc basis at the appropriate call sites through use of casts to determine the function type. In both cases, the deleted-function form is clearer and more concise.}.
+Deleted function declarations are implemented in \CFACC{} by adding them to the symbol table as usual, but with a flag set that indicates that the function is deleted.
+If this deleted declaration is selected as the unique minimal-cost interpretation of an expression than an error is produced. \TODO{Check this is implemented at print.}
+\subsubsection{Traits}
+\CFA{} provides \emph{traits} as a means to name a group of type assertions, as in the example below\footnote{This example uses \CFA{}'s reference types, constructors, and zero type, described in Section~\ref{type-features-sec}.}:
 \begin{cfa}
 …
 Semantically, traits are simply a named list of type assertions, but they may be used for many of the same purposes that interfaces in Java or abstract base classes in \CC{} are used for.
 Unlike Java interfaces or \CC{} base classes, \CFA{} types do not explicitly state any inheritance relationship to traits they satisfy; this can be considered a form of structural inheritance, similar to interface implementation in Go, as opposed to the nominal inheritance model of Java and \CC{}.
+Unlike Java interfaces or \CC{} base classes, \CFA{} types do not explicitly state any inheritance relationship to traits they satisfy; this can be considered a form a structural inheritance, similar to interface implementation in Go, as opposed to the nominal inheritance model of Java and \CC{}.
 Nominal inheritance can be simulated in \CFA{} using marker variables in traits:
 …
 Traits, however, are significantly more powerful than nominal-inheritance interfaces; firstly, due to the scoping rules of the declarations that satisfy a trait's type assertions, a type may not satisfy a trait everywhere that that type is declared, as with !char! and the !nominal! trait above.
 Secondly, because \CFA{} is not object-oriented and types do not have a closed set of methods, existing C library types can be extended to implement a trait simply by writing the requisite functions\footnote{\CC{} only allows partial extension of C types, because constructors, destructors, conversions, and the assignment, indexing, and function-call operators may only be defined in a class; \CFA{} does not have any of these restrictions.}.
+Secondly, because \CFA{} is not object-oriented and types do not have a closed set of methods, existing C library types can be extended to implement a trait simply by writing the requisite functions.
 Finally, traits may be used to declare a relationship among multiple types, a property that may be difficult or impossible to represent in nominal-inheritance type systems\footnote{This example uses \CFA{}'s reference types, described in Section~\ref{type-features-sec}.}:
 …
 \end{cfa}
 In this example above, !(list_iterator, int)! satisfies !pointer_like! by the user-defined dereference function, and !(list_iterator, list)! also satisfies !pointer_like! by the built-in dereference operator for pointers.
+In the example above, !(list_iterator, int)! satisfies !pointer_like! by the user-defined dereference function, and !(list_iterator, list)! also satisfies !pointer_like! by the built-in dereference operator for pointers.
 Given a declaration !list_iterator it!, !*it! can be either an !int! or a !list!, with the meaning disambiguated by context (\eg{} !int x = *it;! interprets !*it! as !int!, while !(*it).value = 42;! interprets !*it! as !list!).
+While a nominal-inheritance system with associated types could model one of those two relationships by making !El! an associated type of !Ptr! in the !pointer_like! implementation,
+I am unaware of any nominal-inheritance system that can model both relationships simultaneously.
+Further comparison of \CFA{} polymorphism with other languages can be found in Section~\ref{generic-related-sec}.
+While a nominal-inheritance system with associated types could model one of those two relationships by making !El! an associated type of !Ptr! in the !pointer_like! implementation, few such systems could model both relationships simultaneously.
 The flexibility of \CFA{}'s implicit trait-satisfaction mechanism provides programmers with a great deal of power, but also blocks some optimization approaches for expression resolution.
+The ability of types to begin or cease to satisfy traits when declarations go into or out of scope makes caching of trait satisfaction judgments difficult, and the ability of traits to take multiple type parameters can lead to a combinatorial explosion of work in any attempt to pre-compute trait satisfaction relationships.
+\subsection{Deleted Declarations}
+Particular type combinations can be exempted from matching a given polymorphic function through the use of a \emph{deleted function declaration}:
+\begin{cfa}
+int somefn(char) = void;
+\end{cfa}
+This feature is based on a \CCeleven{} feature typically used to make a type non-copyable by deleting its copy constructor and assignment operator\footnote{In previous versions of \CC{}, a type could be made non-copyable by declaring a private copy constructor and assignment operator, but not defining either. This idiom is well-known, but depends on some rather subtle and \CC{}-specific rules about private members and implicitly-generated functions; the deleted function form is both clearer and less verbose.} or forbidding some interpretations of a polymorphic function by specifically deleting the forbidden overloads\footnote{Specific polymorphic function overloads can also be forbidden in previous \CC{} versions through use of template metaprogramming techniques, though this advanced usage is beyond the skills of many programmers.}.
+Deleted function declarations are implemented in \CFACC{} by adding them to the symbol table as usual, but with a flag set that indicates that the function is deleted.
+If this deleted declaration is selected as the unique minimal-cost interpretation of an expression then an error is produced, allowing \CFA{} programmers to guide the expression resolver away from undesirable solutions.
+\section{Implicit Conversions} \label{implicit-conv-sec}
+In addition to the multiple interpretations of an expression produced by name overloading and polymorphic functions, \CFA{} must support all of the implicit conversions present in C for backward compatibility, producing further candidate interpretations for expressions.
+As mentioned above, C does not have an inheritance hierarchy of types, but the C standard's rules for the ``usual arithmetic conversions'' \cite[\S{}6.3.1.8]{C11} define which of the built-in types are implicitly convertible to which other types, as well as which implicit conversions to apply for mixed arguments to binary operators.
+The ability of types to begin or cease to satisfy traits when declarations go into or out of scope makes caching of trait satisfaction judgements difficult, and the ability of traits to take multiple type parameters can lead to a combinatorial explosion of work in any attempt to pre-compute trait satisfaction relationships.
+\subsection{Implicit Conversions} \label{implicit-conv-sec}
+In addition to the multiple interpretations of an expression produced by name overloading and polymorphic functions, for backward compatibility \CFA{} must support all of the implicit conversions present in C, producing further candidate interpretations for expressions.
+As mentioned above, C does not have an inheritance hierarchy of types, but the C standard's rules for the ``usual arithmetic conversions'\cit{} define which of the built-in types are implicitly convertible to which other types, and the relative cost of any pair of such conversions from a single source type.
 \CFA{} adds rules to the usual arithmetic conversions defining the cost of binding a polymorphic type variable in a function call; such bindings are cheaper than any \emph{unsafe} (narrowing) conversion, \eg{} !int! to !char!, but more expensive than any \emph{safe} (widening) conversion, \eg{} !int! to !double!.
 One contribution of this thesis, discussed in Section~\ref{conv-cost-sec}, is a number of refinements to this cost model to more efficiently resolve polymorphic function calls.
 In the context of these implicit conversions, the expression resolution problem can be restated as finding the unique minimal-cost interpretation of each expression in the program, where all identifiers must be matched to a declaration, and implicit conversions or polymorphic bindings of the result of an expression may increase the cost of the expression.
 While semantically valid \CFA{} code always has such a unique minimal-cost interpretation, \CFACC{} must also be able to detect and report as errors expressions that have either no interpretation or multiple ambiguous minimal-cost interpretations.
+One contribution of this thesis, discussed in Section \TODO{add to resolution chapter}, is a number of refinements to this cost model to more efficiently resolve polymorphic function calls.
+The expression resolution problem which is the focus of Chapter~\ref{resolution-chap} is to find the unique minimal-cost interpretation of each expression in the program, where all identifiers must be matched to a declaration, and implicit conversions or polymorphic bindings of the result of an expression may increase the cost of the expression.
+While semantically valid \CFA{} code always has such a unique minimal-cost interpretation, \CFACC{} must also be able to detect and report as errors expressions which have either no interpretation or multiple ambiguous minimal-cost interpretations.
 Note that which subexpression interpretation is minimal-cost may require contextual information to disambiguate.
 For instance, in the example in Section~\ref{overloading-sec}, !max(max, -max)! cannot be unambiguously resolved, but !int m = max(max, -max)! has a single minimal-cost resolution.
 While the interpretation !int m = (int)max((double)max, -(double)max)! is also a valid interpretation, it is not minimal-cost due to the unsafe cast from the !double! result of !max! to !int!\footnote{The two \lstinline{double} casts function as type ascriptions selecting \lstinline{double max} rather than casts from \lstinline{int max} to \lstinline{double}, and as such are zero-cost. The \lstinline{int} to \lstinline{double} conversion could be forced if desired with two casts: \lstinline{(double)(int)max}}.
+While the interpretation !int m = (int)max((double)max, -(double)max)! is also a valid interpretation, it is not minimal-cost due to the unsafe cast from the !double! result of !max! to !int!\footnote{The two \lstinline{double} casts function as type ascriptions selecting \lstinline{double max} rather than casts from \lstinline{int max} to \lstinline{double}, and as such are zero-cost.}.
 These contextual effects make the expression resolution problem for \CFA{} both theoretically and practically difficult, but the observation driving the work in Chapter~\ref{resolution-chap} is that of the many top-level expressions in a given program, most are straightforward and idiomatic so that programmers writing and maintaining the code can easily understand them; it follows that effective heuristics for common cases can bring down compiler runtime enough that a small proportion of harder-to-resolve expressions does not inordinately increase overall compiler runtime or memory usage.
 \section{Type Features} \label{type-features-sec}
 The name overloading and polymorphism features of \CFA{} have the greatest effect on language design and compiler runtime, but there are a number of other features in the type system that have a smaller effect but are useful for code examples.
+\subsection{Type Features} \label{type-features-sec}
+The name overloading and polymorphism features of \CFA{} have the greatest effect on language design and compiler runtime, but there are a number of other features in the type system which have a smaller effect but are useful for code examples.
 These features are described here.
 \subsection{Reference Types}
 One of the key ergonomic improvements in \CFA{} is reference types, designed and implemented by Robert Schluntz \cite{Schluntz17}.
+\subsubsection{Reference Types}
+One of the key ergonomic improvements in \CFA{} is reference types, designed and implemented by Robert Schluntz\cite{Schluntz17}.
 Given some type !T!, a !T&! (``reference to !T!'') is essentially an automatically dereferenced pointer.
+These types allow seamless pass-by-reference for function parameters, without the extraneous dereferencing syntax present in C; they also allow easy aliasing of nested values with a similarly convenient syntax.
+The addition of reference types also eliminated two syntactic special-cases present in previous versions of \CFA{}.
+Consider the a call !a += b! to a compound assignment operator.
+The previous declaration for that operator is !lvalue int ?+=?(int*, int)!.
+To mutate the left argument, the built-in operators were special-cased to implicitly take the address of that argument, while the special !lvalue! syntax was used to mark the return type of a function as a mutable reference.
+With references, this declaration is re-written as !int& ?+=?(int&, int)!.
+The reference semantics generalize the implicit address-of on the left argument and allow it to be used in user-declared functions, while also subsuming the (now removed) !lvalue! syntax for function return types.
+The C standard makes heavy use of the concept of \emph{lvalue}, an expression with a memory address; its complement, \emph{rvalue} (a non-addressable expression) is not explicitly named in the standard.
+In \CFA{}, the distinction between lvalue and rvalue can be re-framed in terms of reference and non-reference types, with the benefit of being able to express the difference in user code.
+\CFA{} references preserve the existing qualifier-dropping implicit lvalue-to-rvalue conversion from C (\eg{} a !const volatile int&! can be implicitly copied to a bare !int!).
+To make reference types more easily usable in legacy pass-by-value code, \CFA{} also adds an implicit rvalue-to-lvalue conversion, implemented by storing the value in a compiler-generated temporary variable and passing a reference to that temporary.
+To mitigate the ``!const! hell'' problem present in \CC{}, there is also a qualifier-dropping lvalue-to-lvalue conversion implemented by copying into a temporary:
+These types allow seamless pass-by-reference for function parameters, without the extraneous dereferencing syntax present in C; they also allow easy easy aliasing of nested values with a similarly convenient syntax.
+A particular improvement is removing syntactic special cases for operators which take or return mutable values; for example, the use !a += b! of a compound assignment operator now matches its signature, !int& ?+=?(int&, int)!, as opposed to the previous syntactic special cases to automatically take the address of the first argument to !+=! and to mark its return value as mutable.
+The C standard makes heavy use of the concept of \emph{lvalue}, an expression with a memory address; its complement, \emph{rvalue} (a non-addressable expression) is not explicitly named.
+In \CFA{}, the distinction between lvalue and rvalue can be reframed in terms of reference and non-reference types, with the benefit of being able to express the difference in user code.
+\CFA{} references preserve the existing qualifier-dropping implicit lvalue-to-rvalue conversion from C (\eg{} a !const volatile int&! can be implicitly copied to a bare !int!)
+To make reference types more easily usable in legacy pass-by-value code, \CFA{} also adds an implicit rvalue-to-lvalue conversion, implemented by storing the value in a fresh compiler-generated temporary variable and passing a reference to that temporary.
+To mitigate the ``!const! hell'' problem present in \CC{}, there is also a qualifier-dropping lvalue-to-lvalue conversion, also implemented by copying into a temporary:
 \begin{cfa}
 const int magic = 42;
 void inc_print( int& x ) { printf("%d\n", ++x); }
 inc_print( magic ); $\C{// legal; implicitly generated code in red below:}$
+print_inc( magic ); $\C{// legal; implicitly generated code in red below:}$
 `int tmp = magic;` $\C{// to safely strip const-qualifier}$
 `inc_print( tmp );` $\C{// tmp is incremented, magic is unchanged}$
+`print_inc( tmp );` $\C{// tmp is incremented, magic is unchanged}$
 \end{cfa}
 …
 The primary issue with \CC{} references is that it is impossible to extract the address of the reference variable rather than the address of the referred-to variable.
 This breaks a number of the usual compositional properties of the \CC{} type system, \eg{} a reference cannot be re-bound to another variable, nor is it possible to take a pointer to, array of, or reference to a reference.
 \CFA{} supports all of these use cases without further added syntax.
+\CFA{} supports all of these use cases \TODO{test array} without further added syntax.
 The key to this syntax-free feature support is an observation made by the author that the address of a reference is a lvalue.
 In C, the address-of operator !&x! can only be applied to lvalue expressions, and always produces an immutable rvalue; \CFA{} supports reference re-binding by assignment to the address of a reference\footnote{The syntactic difference between reference initialization and reference assignment is unfortunate, but preserves the ability to pass function arguments by reference (a reference initialization context) without added syntax.}, and pointers to references by repeating the address-of operator:
+In C, the address-of operator !&x! can only be applied to lvalue expressions, and always produces an immutable rvalue; \CFA{} supports reference re-binding by assignment to the address of a reference, and pointers to references by repeating the address-of operator:
 \begin{cfa}
 …
 \end{cfa}
 For better compatibility with C, the \CFA{} team has chosen not to differentiate function overloads based on top-level reference types, and as such their contribution to the difficulty of \CFA{} expression resolution is largely restricted to the implementation details of matching reference to non-reference types during type-checking.
 \subsection{Resource Management} \label{ctor-sec}
 \CFA{} also supports the RAII (``Resource Acquisition is Initialization'') idiom originated by \CC{}, thanks to the object lifetime work of Robert Schluntz \cite{Schluntz17}.
+For better compatibility with C, the \CFA{} team has chosen not to differentiate function overloads based on top-level reference types, and as such their contribution to the difficulty of \CFA{} expression resolution is largely restricted to the implementation details of normalization conversions and adapters.
+\subsubsection{Resource Management}
+\CFA{} also supports the RAII (``Resource Acquisition is Initialization'') idiom originated by \CC{}, thanks to the object lifetime work of Robert Schluntz\cite{Schluntz17}.
 This idiom allows a safer and more principled approach to resource management by tying acquisition of a resource to object initialization, with the corresponding resource release executed automatically at object finalization.
 A wide variety of conceptual resources may be conveniently managed by this scheme, including heap memory, file handles, and software locks.
 …
 \end{cfa}
 \subsection{Tuple Types}
+\subsubsection{Tuple Types}
 \CFA{} adds \emph{tuple types} to C, a syntactic facility for referring to lists of values anonymously or with a single identifier.
 An identifier may name a tuple, a function may return one, and a tuple may be implicitly \emph{destructured} into its component values.
 The implementation of tuples in \CFACC{}'s code generation is based on the generic types introduced in Chapter~\ref{generic-chap}, with one compiler-generated generic type for each tuple arity.
 This reuse allows tuples to take advantage of the same runtime optimizations available to generic types, while reducing code bloat.
 An extended presentation of the tuple features of \CFA{} can be found in \cite{Moss18}, but the following example demonstrates the basic features:
 \begin{cfa}
 [char, char] x$\(_1\)$ = ['!', '?']; $\C{// tuple type and expression syntax}$
 int x$\(_2\)$ = 2;
+This allows tuples to take advantage of the same runtime optimizations available to generic types, while reducing code bloat.
+An extended presentation of the tuple features of \CFA{} can be found in \cite{Moss18}, but the following example shows the basics:
+\begin{cfa}
+[char, char] x = ['!', '?']; $\C{// (1); tuple type and expression syntax}$
+int x = 2; $\C{// (2)}$
 forall(otype T)
 [T, T] swap$\(_1\)$( T a, T b ) {
+[T, T] swap( T a, T b ) { $\C{// (3)}$
         return [b, a]; $\C{// one-line swap syntax}$
+}
 x = swap( x ); $\C{// destructure x\(_1\) into two elements}$
 $\C{// cannot use x\(_2\), not enough arguments}$
 void swap$\(_2\)$( int, char, char );
 swap( x, x ); $\C{// swap\(_2\)( x\(_2\), x\(_1\) )}$
 $\C{// not swap\(_1\)( x\(_2\), x\(_2\) ) due to polymorphism cost}$
+x = swap( x ); $\C{// destructure [char, char] x into two elements}$
+$\C{// cannot use int x, not enough arguments}$
+void swap( int, char, char ); $\C{// (4)}$
+swap( x, x ); $\C{// (4) on (2), (1)}$
+$\C{// not (3) on (2), (2) due to polymorphism cost}$
 \end{cfa}
 Tuple destructuring breaks the one-to-one relationship between identifiers and values.
+Hence, some argument-parameter matching strategies for expression resolution are precluded, as well as cheap interpretation filters based on comparing number of parameters and arguments.
+As an example, in the call to !swap( x, x )! above, the second !x! can be resolved starting at the second or third parameter of !swap!$_2$, depending which interpretation of !x! is chosen for the first argument.
+\section{Conclusion}
+\CFA{} adds a significant number of features to standard C, increasing the expressivity and re-usability of \CFA{} code while maintaining backwards compatibility for both code and larger language paradigms.
+This flexibility does incur significant added compilation costs, however, the mitigation of which are the primary concern of this thesis.
+This precludes some argument-parameter matching strategies for expression resolution, as well as cheap interpretation filters based on comparing number of parameters and arguments.
+As an example, in the call to !swap( x, x )! above, the second !x! can be resolved starting at the second or third parameter of !swap!, depending which interpretation of !x! was chosen for the first argument.

doc/theses/aaron_moss_PhD/phd/conclusion.tex

-              r933f32f
+              r6a9d4b4
 \chapter{Conclusion}
+Decades after its first standardization, the C language remains a widely-used tool and a vital part of the software development landscape.
+The \CFA{} language under development at the University of Waterloo represents an evolutionary modernization of C with expressive modern language features paired with strong C backwards-compatibility.
+This thesis has contributed to these project goals in a variety of ways, including the addition of a generic-types language feature (Chapter~\ref{generic-chap}) and refinement of the \CFA{} overload selection rules to produce a more expressive and intuitive model (Section~\ref{conv-cost-sec}).
+Based on the technical contribution of the resolver prototype system (Section~\ref{rp-features-sec}), I have also made significant improvements to \CFA{} compilation performance, including un-combined bottom-up expression traversal (Section~\ref{arg-parm-matching-sec}), deferred-cached assertion satisfaction (Section~\ref{assn-sat-sec}), and a novel persistent union-find type environment data structure (Section~\ref{env-persistent-union-find}).
+The combination of these practical improvements and added features significantly improve the viability of \CFA{} as a practical programming language.
+Further improvements to the \CFA{} type system are still possible, however.
+One area suggested by this work is development of a scheme for user-defined conversions; to integrate properly with the \CFA{} conversion model, there would need to be a distinction between safe and unsafe conversions, and possibly a way to denote conversions as explicit-only or non-chainable.
+Another place for ongoing effort is improvement of compilation performance; I believe the most promising direction for that effort is rebuilding the \CFA{} compiler on a different framework than Bilson's \CFACC{}.
+The resolver prototype presented in this work has good performance and already has the basics of \CFA{} semantics implemented, as well as many of the necessary core data structures, and would be a viable candidate for a new compiler architecture.
+An alternate approach would be to fork an existing C compiler such as Clang~\cite{Clang}, which would need to be modified to use one of the resolution algorithms discussed here, as well as various other features introduced by Bilson~\cite{Bilson03}.
+More generally, the algorithmic techniques described in this thesis may be useful to implementors of other programming languages.
+In particular, the demonstration of practical performance for polymorphic return-type inference suggests the possibility of eliding return-type-only template parameters in \CC{} function calls, though integrating such an extension into \CC{} expression resolution in a backwards-compatible manner may be challenging.
+The \CFA{} expression resolution problem also bears some similarity to the \emph{local type inference} model put forward by Pierce \& Turner \cite{Pierce00} and Odersky \etal{} \cite{Odersky01}; compiler implementors for languages like Scala \cite{Scala}, which performs type inference based on this model, may be able to profitably adapt the algorithms and data structures presented in this thesis.
+Wrap it up --- Done, done done.

doc/theses/aaron_moss_PhD/phd/evaluation/generic-timing.dat

r933f32f	r6a9d4b4
8	8	"clear\npair" 2840 773 748 3511
9	9	"pop\npair" 3025 5414 813 23867
	10

doc/theses/aaron_moss_PhD/phd/frontpgs.tex

-              r933f32f
+              r6a9d4b4
         \bigskip
+        \noindent
+  \begin{tabbing}
+  Internal-External Member: \=  \kill % using longest text to define tab length
+  External Examiner: \>  Doug Lea \\
+  \> Professor, Computer Science Department, \\
+  \> State University of New York at Oswego \\
+  \end{tabbing}
+        \bigskip
+%       \noindent
+%   \begin{tabbing}
+%   Internal-External Member: \=  \kill % using longest text to define tab length
+%   External Examiner: \>  Bruce Bruce \\
+%   \> Professor, Dept. of Philosophy of Zoology, University of Wallamaloo \\
+%   \end{tabbing}
+%       \bigskip
         \noindent
 …
   Internal-External Member: \=  \kill % using longest text to define tab length
   Supervisor: \> Peter Buhr \\
+  \> Associate Professor, School of Computer Science, \\
+  \> University of Waterloo \\
+  \> Professor, School of Computer Science, University of Waterloo \\
   \end{tabbing}
         \bigskip
 …
   \begin{tabbing}
   Internal-External Member: \=  \kill % using longest text to define tab length
+  Internal Members: \> Ond\v{r}ej Lhot\a'ak \\
+  \> Associate Professor, School of Computer Science, \\
+  \>University of Waterloo \\
+  \\
+  \> Gregor Richards \\
+  \> Assistant Professor, School of Computer Science, \\
+  \> University of Waterloo \\
+  Internal Members: \> Gregor Richards \\
+  \> Professor, School of Computer Science, University of Waterloo \\
+  \> Ond\v{r}ej Lhot\a'ak \\
+  \> Professor, School of Computer Science, University of Waterloo \\
   \end{tabbing}
         \bigskip
+%       \bigskip
+        \noindent
+  \begin{tabbing}
+  Internal-External Member: \=  \kill % using longest text to define tab length
+  Internal-External Member: \> Werner Dietl \\
+  \> Assistant Professor, Electrical and Computer Engineering, \\
+  \> University of Waterloo \\
+  \end{tabbing}
+%       \bigskip
+%       \noindent
+%   \begin{tabbing}
+%   Internal-External Member: \=  \kill % using longest text to define tab length
+%   Internal-External Member: \> Deepa Thotta \\
+%   \> Professor, Dept. of Philosophy, University of Waterloo \\
+%   \end{tabbing}
+%       \bigskip
 %       \noindent
 …
 \begin{center}\textbf{Abstract}\end{center}
+        The C programming language has been an important software development tool for decades.
+        \CFA{} is a new programming language designed with strong backwards-compatibility to take advantage of widely distributed C programming expertise and the large deployed base of C code, paired with modern language features to improve developer productivity.
+        This thesis presents a number of improvements to \CFA{}.
+        The author has developed one major new language feature, generic types, in a way that integrates naturally with both the existing polymorphism features of \CFA{} and the translation-unit-based encapsulation model of C.
+        This thesis also presents a number of smaller refinements to the \CFA{} overload resolution rules, each of which improves the expressivity or intuitive nature of the language.
+        This thesis also includes a number of practical improvements to \CFA{} compilation performance, focused on the expression resolution pass, which is the main bottleneck.
+        These include better algorithms for argument-parameter matching and type assertion satisfaction, as well as a new type-environment data-structure based on a novel variant of union-find.
+        The compilation performance improvements have all been experimentally validated with a new prototype system that encapsulates the key aspects of the \CFA{} language; this prototype is a promising basis for future research and a technical contribution of this work.
+        \CFA{}, extended and refined in this thesis, presents both an independently interesting combination of language features and a comprehensive approach to the modernization of C.
+        This work demonstrates the hitherto unproven compiler-implementation viability of the \CFA{} language design, and provides a number of useful tools to implementors of other languages.
+This is the abstract.
 \cleardoublepage
 …
 % -------------------------------
 \begin{center}\textbf{Acknowledgements}\end{center}
+% \begin{center}\textbf{Acknowledgements}\end{center}
+Though a doctoral thesis is an individual project, I could not have completed it without the help and support of many members of my community.
+This thesis would not exist in the form it does without the mentorship of my advisor, Peter Buhr, who has ably led the \CFA{} team while giving me both the advantage of his decades of experience and the freedom to follow my own interests.
+My work on \CFA{} does not exist in a vacuum, and it has been a pleasure and a privilege to collaborate with the members of the \CFA{} team: Andrew Beach, Richard Bilson, Michael Brooks, Bryan Chan, Thierry Delisle, Glen Ditchfield, Brice Dobry, Rob Schluntz, and others.
+I gratefully acknowledge the financial support of the National Science and Engineering Council of Canada and Huawei Ltd.\ for this project.
+I would also like to thank of my thesis committee, Werner Dietl, Doug Lea, Ond\v{r}ej Lhot\a'ak, and Gregor Richards, for the time and effort they have invested in providing constructive feedback to refine this work.
+I am indebted to Peter van Beek and Ian Munro for their algorithmic expertise and willingness to share their time with me.
+I have far too many colleagues in the Programming Languages Group and School of Computer Science to name, but I deeply appreciate their camaraderie; specifically with regard to the production of this thesis, I would like to thank Nathan Fish for recommending my writing soundtrack, and Sharon Choy for her unfailing supply of encouraging rabbit animations.
+Finally, to all my friends and family who have supported me and made Kitchener-Waterloo home these past seven years, thank you, I could not have done it without you; most especially, Christina Moss, you are the best of wives and best of women, your support has kept me going through the ups and downs of research, and your partnership is key to all my successes.
+\cleardoublepage
+% I would like to thank all the little people who made this thesis possible.
+% \cleardoublepage
 % D E D I C A T I O N
 …
 % \begin{center}\textbf{Dedication}\end{center}
+% To Christina, who has spent too many hours politely listening to me work out the technical minutiae of this thesis, I love you, and I won't make you read it.
+% This is dedicated to the one I love.
 % \cleardoublepage

doc/theses/aaron_moss_PhD/phd/generic-types.tex

-              r933f32f
+              r6a9d4b4
 While this approach is flexible and supports integration with the C type checker and tooling, it is also tedious and error prone, especially for more complex data structures.
 A second approach is to use !void*!-based polymorphism, \eg{} the C standard library functions !bsearch! and !qsort!, which allow for the reuse of common functionality.
 However, basing all polymorphism on !void*! eliminates the type checker's ability to ensure that argument types are properly matched, often requiring a number of extra function parameters, pointer indirection, and dynamic allocation that is otherwise unnecessary.
+However, basing all polymorphism on !void*! eliminates the type checker's ability to ensure that argument types are properly matched, often requiring a number of extra function parameters, pointer indirection, and dynamic allocation that is otherwise not needed.
 A third approach to generic code is to use preprocessor macros, which does allow the generated code to be both generic and type checked, but errors in such code may be difficult to locate and debug.
 Furthermore, writing and using preprocessor macros is unnatural and inflexible.
 Figure~\ref{bespoke-generic-fig} demonstrates the bespoke approach for a simple linked list with !insert! and !head! operations, while Figure~\ref{void-generic-fig} and Figure~\ref{macro-generic-fig} show the same example using !void*! and !#define!-based polymorphism, respectively.
+Figure~\ref{bespoke-generic-fig} demonstrates the bespoke approach for a simple linked list with !insert! and !head! operations, while Figure~\ref{void-generic-fig} and Figure~\ref{macro-generic-fig} show the same example using !void*!- and !#define!-based polymorphism, respectively.
 \begin{figure}
         \begin{cfa}
-                #include <stdlib.h> $\C{// for malloc}$
-                #include <stdio.h>  $\C{// for printf}$
                 struct int_list { int value; struct int_list* next; };
 …
                 int int_list_head( const struct int_list* ls ) { return ls->value; }
                 // all code must be duplicated for every generic instantiation
+                $\C[\textwidth]{// all code must be duplicated for every generic instantiation}$
                 struct string_list { const char* value; struct string_list* next; };
 …
                         { return ls->value; }
                 // use is efficient and idiomatic
+                $\C[\textwidth]{// use is efficient and idiomatic}$
                 int main() {
 …
 \begin{figure}
         \begin{cfa}
-                #include <stdlib.h> $\C{// for malloc}$
-                #include <stdio.h>  $\C{// for printf}$
                 // single code implementation
                 struct list { void* value; struct list* next; };
                 // internal memory management requires helper functions
+                $\C[\textwidth]{// internal memory management requires helper functions}$
                 void list_insert( struct list** ls, void* x, void* (*copy)(void*) ) {
 …
                 void* list_head( const struct list* ls ) { return ls->value; }
                 // helpers duplicated per type
+                $\C[\textwidth]{// helpers duplicated per type}$
                 void* int_copy(void* x) {
 …
 \begin{figure}
         \begin{cfa}
+                #include <stdlib.h> $\C{// for malloc}$
+                #include <stdio.h>  $\C{// for printf}$
+                // code is nested in macros
+                $\C[\textwidth]{// code is nested in macros}$
                 #define list(N) N ## _list
 …
                 define_list(string, const char*); $\C[3in]{// defines string\_list}$
                 // use is efficient, but syntactically idiosyncratic
+                $\C[\textwidth]{// use is efficient, but syntactically idiosyncratic}$
                 int main() {
 …
 \end{figure}
 \CC{}, Java, and other languages use \emph{generic types} (or \emph{parameterized types}) to produce type-safe abstract data types.
 Design and implementation of generic types for \CFA{} is the first major contribution of this thesis, a summary of which is published in \cite{Moss18} and on which this chapter is closely based.
+\CC{}, Java, and other languages use \emph{generic types} to produce type-safe abstract data types.
+Design and implementation of generic types for \CFA{} is the first major contribution of this thesis, a summary of which is published in \cite{Moss18} and from which this chapter is closely based.
 \CFA{} generic types integrate efficiently and naturally with the existing polymorphic functions in \CFA{}, while retaining backward compatibility with C in layout and support for separate compilation.
 A generic type can be declared in \CFA{} by placing a !forall! specifier on a !struct! or !union! declaration, and instantiated using a parenthesized list of types after the generic name.
 An example comparable to the C polymorphism examples in Figures~\ref{bespoke-generic-fig}, \ref{void-generic-fig}, and \ref{macro-generic-fig} can be seen in Figure~\ref{cfa-generic-fig}.
+An example comparable to the C polymorphism examples in Figures~\ref{bespoke-generic-fig}, \ref{void-generic-fig}, and \ref{macro-generic-fig} can be seen in Figure~\ref{cfa-generic-fig} \TODO{test this code}.
 \begin{figure}
         \begin{cfa}
-                #include <stdlib.hfa> $\C{// for alloc}$
-                #include <stdio.h>  $\C{// for printf}$
                 forall(otype T) struct list { T value; list(T)* next; };
                 // single polymorphic implementation of each function
                 // overloading reduces need for namespace prefixes
+                $\C[\textwidth]{// single polymorphic implementation of each function}$
+                $\C[\textwidth]{// overloading reduces need for namespace prefixes}$
                 forall(otype T) void insert( list(T)** ls, T x ) {
 …
                 forall(otype T) T head( const list(T)* ls ) { return ls->value; }
                 // use is clear and efficient
+                $\C[\textwidth]{// use is clear and efficient}$
                 int main() {
 …
 \section{Design}
 Though a number of languages have some implementation of generic types, backward compatibility with both C and existing \CFA{} polymorphism present some unique design constraints for \CFA{} generics.
 The guiding principle is to maintain an unsurprising language model for C programmers without compromising runtime efficiency.
 A key insight for this design is that C already possesses a handful of built-in generic types (\emph{derived types} in the language of the standard \cite[\S{}6.2.5]{C11}), notably pointer (!T*!) and array (!T[]!), and that user-definable generics should act similarly.
 \subsection{Related Work} \label{generic-related-sec}
 One approach to the design of generic types is that taken by \CC{} templates \cite{C++}.
+Though a number of languages have some implementation of generic types, backward compatibility with both C and existing \CFA{} polymorphism presented some unique design constraints for this project.
+The guiding principle was to maintain an unsurprising language model for C programmers without compromising runtime efficiency.
+A key insight for this design was that C already possesses a handful of built-in generic types (\emph{compound types} in the language of the standard\cit{}), notably pointer (!T*!) and array (!T[]!), and that user-definable generics should act similarly.
+\subsection{Related Work}
+One approach to the design of generic types is that taken by \CC{} templates\cite{C++}.
 The template approach is closely related to the macro-expansion approach to C polymorphism demonstrated in Figure~\ref{macro-generic-fig}, but where the macro-expansion syntax has been given first-class language support.
 Template expansion has the benefit of generating code with near-optimal runtime efficiency, as distinct optimizations can be applied for each instantiation of the template.
 On the other hand, template expansion can also lead to significant code bloat, exponential in the worst case \cite{Haberman16}, and the costs of increased compilation time and instruction cache pressure cannot be ignored.
+On the other hand, template expansion can also lead to significant code bloat, exponential in the worst case\cit{}, and the costs of increased instruction cache pressure at runtime and wasted developer time when compiling cannot be discounted.
 The most significant restriction of the \CC{} template model is that it breaks separate compilation and C's translation-unit-based encapsulation mechanisms.
 Because a \CC{} template is not actually code, but rather a ``recipe'' to generate code, template code must be visible at its call site to be used.
 Furthermore, \CC{} template code cannot be type-checked without instantiating it, a time consuming process with no hope of improvement until \CC{} concepts \cite{C++Concepts} are standardized in \CCtwenty{}.
 C code, by contrast, only needs a function declaration to call that function or a !struct! declaration to use (by-pointer) values of that type, desirable properties to maintain in \CFA{}.
 Java \cite{Java8} has another prominent implementation for generic types, introduced in Java~5 and based on a significantly different approach than \CC{}.
+Because a \CC{} template is not actually code, but rather a sort of ``recipe'' to generate code, template code must be visible at its call site to be used.
+Furthermore, \CC{} template code cannot be type-checked without instantiating it, a time consuming process with no hope of improvement until \CC{} concepts\cite{C++Concepts} are standardized in \CCtwenty{}.
+C code, by contrast, only needs a !struct! or function declaration to call that function or use (by-pointer) values of that type, a desirable property to maintain for \CFA{}.
+Java\cite{Java8} has another prominent implementation for generic types, introduced in Java~5 and based on a significantly different approach than \CC{}.
 The Java approach has much more in common with the !void*!-polymorphism shown in Figure~\ref{void-generic-fig}; since in Java nearly all data is stored by reference, the Java approach to polymorphic data is to store pointers to arbitrary data and insert type-checked implicit casts at compile-time.
 This process of \emph{type erasure} has the benefit of allowing a single instantiation of polymorphic code, but relies heavily on Java's object model.
+This process of \emph{type erasure} has the benefit of allowing a single instantiation of polymorphic code, but relies heavily on Java's object model and garbage collector.
 To use this model, a more C-like language such as \CFA{} would be required to dynamically allocate internal storage for variables, track their lifetime, and properly clean them up afterward.
 Cyclone \cite{Grossman06} extends C and also provides capabilities for polymorphic functions and existential types which are similar to \CFA{}'s !forall! functions and generic types.
+Cyclone\cite{Grossman06} is another language extending C, and also provides capabilities for polymorphic functions and existential types, similar to \CFA{}'s !forall! functions and generic types.
 Cyclone existential types can include function pointers in a construct similar to a virtual function table, but these pointers must be explicitly initialized at some point in the code, which is tedious and error-prone compared to \CFA{}'s implicit assertion satisfaction.
 Furthermore, Cyclone's polymorphic functions and types are restricted to abstraction over types with the same layout and calling convention as !void*!, \ie{} only pointer types and !int!.
 …
 Many other languages include some form of generic types.
 As a brief survey, ML \cite{ML} was the first language to support parametric polymorphism, but unlike \CFA{} does not support the use of assertions and traits to constrain type arguments.
 Haskell \cite{Haskell10} combines ML-style polymorphism with the notion of type classes, similar to \CFA{} traits, but requiring an explicit association with their implementing types, unlike \CFA{}.
 Objective-C \cite{obj-c-book} is an extension to C which has had some industrial success; however, it did not support type-checked generics until recently \cite{xcode7}, and its garbage-collected, message-passing object-oriented model is a radical departure from C.
 Go \cite{Go}, and Rust \cite{Rust} are modern compiled languages with abstraction features similar to \CFA{} traits: \emph{interfaces} in Go and \emph{traits} in Rust.
 Go has implicit interface implementation and uses a ``fat pointer'' construct to pass polymorphic objects to functions, similar in principle to \CFA{}'s implicit forall parameters.
+As a brief survey, ML\cite{ML} was the first language to support parameteric polymorphism, but unlike \CFA{} does not support the use of assertions and traits to constrain type arguments.
+Haskell\cite{Haskell10} combines ML-style polymorphism with the notion of type classes, similar to \CFA{} traits, but requiring an explicit association with their implementing types, unlike \CFA{}.
+Objective-C\cite{obj-c-book} is an extension to C which has had some industrial success; however, it did not support type-checked generics until recently\cite{xcode7}, and it's garbage-collected, message-passing object-oriented model is a radical departure from C.
+Go\cite{Go}, and Rust\cite{Rust} are modern compiled languages with abstraction features similar to \CFA{} traits, \emph{interfaces} in Go and \emph{traits} in Rust.
+Go has implicit interface implementation and uses a ``fat pointer'' construct to pass polymorphic objects to functions, similar in principle to \CFA{}'s implicit forall paramters.
 Go does not, however, allow user code to define generic types, restricting Go programmers to the small set of generic types defined by the compiler.
 Rust has powerful abstractions for generic programming, including explicit implementation of traits and options for both separately-compiled virtual dispatch and template-instantiated static dispatch in functions.
+Rust has powerful abstractions for generic programming, including explicit implemenation of traits and options for both separately-compiled virtual dispatch and template-instantiated static dispatch in functions.
 On the other hand, the safety guarantees of Rust's \emph{lifetime} abstraction and borrow checker impose a distinctly idiosyncratic programming style and steep learning curve; \CFA{}, with its more modest safety features, allows direct ports of C code while maintaining the idiomatic style of the original source.
 \subsection{\CFA{} Generics}
 The generic types design in \CFA{} draws inspiration from both \CC{} and Java generics, capturing useful aspects of each.
 Like \CC{} template types, generic !struct! and !union! types in \CFA{} have macro-expanded storage layouts, but, like Java generics, \CFA{} generic types can be used with separately-compiled polymorphic functions without requiring either the type or function definition to be visible to the other.
+The generic types design in \CFA{} draws inspiration from both \CC{} and Java generics, capturing the better aspects of each.
+Like \CC{} template types, generic !struct!s and !union!s in \CFA{} have macro-expanded storage layouts, but, like Java generics, \CFA{} generic types can be used with separately-compiled polymorphic functions without requiring either the type or function definition to be visible to the other.
 The fact that the storage layout of any instantiation of a \CFA{} generic type is identical to that of the monomorphic type produced by simple macro replacement of the generic type parameters is important to provide consistent and predictable runtime performance, and to not impose any undue abstraction penalty on generic code.
+As an example, consider the following generic type and function:
+% TODO whatever the bug is with initializer-expressions not working, it affects this
+As an example, consider the following generic type and function \TODO{test this}:
 \begin{cfa}
 forall( otype R, otype S ) struct pair { R first; S second; };
 pair(const char*, int) with_len( const char* s ) {
         return (pair(const char*, int)){ s, strlen(s) };
+        return (pair(const char*), int){ s, strlen(s) };
+}
 \end{cfa}
 In this example, !with_len! is defined at the same scope as !pair!, but it could be called from any context that can see the definition of !pair! and a declaration of !with_len!.
 If its return type were !pair(const char*, int)*!, callers of !with_len! would only need the declaration !forall(otype R, otype S) struct pair! to call it, in accordance with the usual C rules for opaque types.
 !with_len! is itself a monomorphic function, returning a type that is structurally identical to !struct { const char* first; int second; }!, and as such could be called from C given appropriate re-declarations and demangling flags.
 However, the definition of !with_len! depends on a polymorphic function call to the !pair! constructor, which only needs to be written once (in this case, implicitly by the compiler according to the usual \CFA{} constructor generation \cite{Schluntz17}) and can be re-used for a wide variety of !pair! instantiations.
 Since the parameters to this polymorphic constructor call are all statically known, compiler inlining can in principle eliminate any runtime overhead of this polymorphic call.
+If its return type was !pair(const char*, int)*!, callers of !with_len! would only need the declaration !forall(otype R, otype S) struct pair! to call it, in accordance with the usual C rules for opaque types.
+!with_len! is itself a monomorphic function, returning a type that is structurally identical to !struct { const char* first; int second; }!, and as such could be called from C given an appropriate redeclaration and demangling flags.
+However, the definition of !with_len! depends on a polymorphic function call to the !pair! constructor, which only needs to be written once (in this case, implicitly by the compiler according to the usual \CFA{} constructor generation\cite{Moss18}) and can be re-used for a wide variety of !pair! instantiations.
+Since the parameters to this polymorphic constructor call are all statically known, compiler inlining can eliminate any runtime overhead of this polymorphic call.
 \CFA{} deliberately does not support \CC{}-style partial specializations of generic types.
 A particularly infamous example in the \CC{} standard library is !vector<bool>!, which is represented as a bit-string rather than the array representation of the other !vector! instantiations.
+A particularly infamous example in the \CC{} standard library is !vector<bool>!, which is represented as a bitstring rather than the array representation of the other !vector! instantiations.
 Complications from this inconsistency (chiefly the fact that a single bit is not addressable, unlike an array element) make the \CC{} !vector! unpleasant to use in generic contexts due to the break in its public interface.
 Rather than attempting to plug leaks in the template specialization abstraction with a detailed method interface, \CFA{} takes the more consistent position that two types with an unrelated data layout are in fact unrelated types, and should be handled with different code.
 Of course, to the degree that distinct types are similar enough to share an interface, the \CFA{} !trait! system allows such an interface to be defined, and objects of types implementing that !trait! to be operated on using the same polymorphic functions.
+Rather than attempting to plug leaks in the template specialization abstraction with a detailed method interface, \CFA{} takes the more principled position that two types with an unrelated data layout are in fact unrelated types, and should be handled with different code.
+Of course, to the degree that distinct types are similar enough to share an interface, the \CFA{} !trait! system allows one to be defined, and objects of types implementing that !trait! to be operated on in the same polymorphic functions.
 Since \CFA{} polymorphic functions can operate over polymorphic generic types, functions over such types can be partially or completely specialized using the usual overload selection rules.
 As an example, the following generalization of !with_len! is a semantically-equivalent function which works for any type that has a !len! function declared, making use of both the ad-hoc (overloading) and parametric (!forall!) polymorphism features of \CFA{}:
+As an example, the !with_len! function above could be an optimization of the following more general function:
 \begin{cfa}
 …
 \end{cfa}
 \CFA{} generic types also support type constraints, as in !forall! functions.
+\CFA{} generic types also support the type constraints from !forall! functions.
 For example, the following declaration of a sorted set type ensures that the set key implements equality and relational comparison:
 …
 \end{cfa}
 These constraints are enforced by applying equivalent constraints to the compiler-generated constructors for this type.
+These constraints are implemented by applying equivalent constraints to the compiler-generated constructors for this type.
 \section{Implementation} \label{generic-impl-sec}
+The ability to use generic types in polymorphic contexts means that the \CFA{} implementation must support a mechanism for accessing fields of generic types dynamically.
+While \CFACC{} could in principle use this same mechanism for accessing fields of generic types in monomorphic contexts as well, such an approach would throw away compiler knowledge of static types and impose an unnecessary runtime cost.
+Instead, my design for generic types in \CFACC{} distinguishes between \emph{concrete} generic types that have a fixed memory layout regardless of type parameters and \emph{dynamic} generic types that may vary in memory layout depending on their type parameters.
+The ability to use generic types in polymorphic contexts means that the \CFA{} implementation in \CFACC{} must support a mechanism for accessing fields of generic types dynamically at runtime.
+While \CFACC{} could in principle use this same mechanism for accessing fields of all generic types, such an approach would throw away compiler knowledge of static types and impose an unnecessary runtime cost, limiting the utility of the generic type design.
+Instead, my design for generic type support in \CFACC{} distinguishes between \emph{concrete} generic types that have a fixed memory layout regardless of type parameters and \emph{dynamic} generic types that may vary in memory layout depending on their type parameters.
 A \emph{dtype-static} type has polymorphic parameters but is still concrete.
 Polymorphic pointers are an example of dtype-static types; given some type variable !T!, !T! is a polymorphic type, but !T*! has a fixed size and can therefore be represented by a !void*! in code generation.
 In particular, generic types where all parameters are un-!sized! (\ie{} they do not conform to the built-in !sized! trait, which is satisfied by all types the compiler knows the size and alignment of) are always concrete, as there is no possibility for their layout to vary based on type parameters of unknown size and alignment.
+Polymorphic pointers are an example of dtype-static types; given some type variable !T!, T is a polymorphic type, but !T*! has a fixed size and can therefore be represented by a !void*! in code generation.
+In particular, generic types where all parameters are un-!sized! (\ie{} they do not conform to the built-in !sized! trait because the compiler does not know their size and alignment) are always concrete, as there is no possibility for their layout to vary based on type parameters of unknown size and alignment.
 More precisely, a type is concrete if and only if all of its !sized! type parameters are concrete, and a concrete type is dtype-static if any of its type parameters are (possibly recursively) polymorphic.
+To illustrate, the following code using the !pair! type from above has each use of !pair! commented with its class:
+% TODO constructor bugs here too
+To illustrate, the following code using the !pair! type from above \TODO{test this} has each use of !pair! commented with its class:
 \begin{cfa}
 //dynamic, layout varies based on T
 forall(otype T) T value$\(_1\)$( pair(const char*, T) p ) { return p.second; }
+forall(otype T) T value( pair(const char*, T) p ) { return p.second; }
 // dtype-static, F* and T* are concrete but recursively polymorphic
 forall(dtype F, otype T) T value$\(_2\)$( pair(F*, T*) ) { return *p.second; }
+forall(dtype F, otype T) T value( pair(F*, T*) ) { return *p.second; }
 pair(const char*, int) p = {"magic", 42}; $\C[2.5in]{// concrete}$
 int i = value(p);
 pair(void*, int*) q = {0, &i}; $\C[2.5in]{// concrete}$
+pair(void*, int*) q = {0, &p.second}; $\C[2.5in]{// concrete}$
 i = value(q);
 double d = 1.0;
 …
 \subsection{Concrete Generic Types}
 The \CFACC{} translator template-expands concrete generic types into new structure types, affording maximal inlining.
+The \CFACC{} translator template expands concrete generic types into new structure types, affording maximal inlining.
 To enable interoperation among equivalent instantiations of a generic type, \CFACC{} saves the set of instantiations currently in scope and reuses the generated structure declarations where appropriate.
 In particular, tuple types are implemented as a single compiler-generated generic type definition per tuple arity, and can be instantiated and reused according to the usual rules for generic types.
 A function declaration that accepts or returns a concrete generic type produces a declaration for the instantiated structure in the same scope, which all callers may reuse.
 As an example, the concrete instantiation for !pair(const char*, int)! is\footnote{Field name mangling for overloading purposes is omitted.\label{mangle-foot}}:
+As an example, the concrete instantiation for !pair(const char*, int)! is\footnote{This omits the field name mangling performed by \CFACC{} for overloading purposes.\label{mangle-foot}}
 \begin{cfa}
 …
 A concrete generic type with dtype-static parameters is also expanded to a structure type, but this type is used for all matching instantiations.
 In the example above, the !pair(F*, T*)! parameter to !value! is such a type; its expansion is below\footref{mangle-foot}, and it is used as the type of the variables !q! and !r! as well, with casts for member access where appropriate:
+In the example above, the !pair(F*, T*)! parameter to !value! is such a type; its expansion is below\footref{mangle-foot}, and it is used as the type of the variables !q! and !r! as well, with casts for member access where appropriate.
 \begin{cfa}
 …
 The design for generic types presented here adds an \emph{offset array} containing structure-member offsets for dynamic generic !struct! types.
 A dynamic generic !union! needs no such offset array, as all members are at offset 0, but size and alignment are still necessary.
 Access to members of a dynamic structure is provided at runtime via base-displacement addressing of the structure pointer and the member offset (similar to the !offsetof! macro), moving a compile-time offset calculation to runtime.
 The offset arrays are statically generated where possible.
+Access to members of a dynamic structure is provided at runtime via base displacement addressing the structure pointer and the member offset (similar to the !offsetof! macro), moving a compile-time offset calculation to runtime.
+the offset arrays are statically generated where possible.
 If a dynamic generic type is passed or returned by value from a polymorphic function, \CFACC{} can safely assume that the generic type is complete (\ie{} has a known layout) at any call site, and the offset array is passed from the caller; if the generic type is concrete at the call site, the elements of this offset array can even be statically generated using the C !offsetof! macro.
 As an example, the body of !value!$_2$ above is implemented as:
+As an example, the body of the second !value! function above is implemented as
 \begin{cfa}
 …
 \end{cfa}
 Here, !_assign_T! is passed in as an implicit parameter from !otype T! and takes two !T*! (!void*! in the generated code\footnote{A GCC extension allows arithmetic on \lstinline{void*}, calculated as if \lstinline{sizeof(void) == 1}.}), a destination and a source, and !_retval! is the pointer to a caller-allocated buffer for the return value, the usual \CFA{} method to handle dynamically-sized return types.
 !_offsetof_pair! is the offset array passed into !value!; this array is statically generated at the call site as:
+Here, !_assign_T! is passed in as an implicit parameter from !otype T! and takes two !T*! (!void*! in the generated code), a destination and a source, and !_retval! is the pointer to a caller-allocated buffer for the return value, the usual \CFA{} method to handle dynamically-sized return types.
+!_offsetof_pair! is the offset array passed into !value!; this array is generated at the call site as
 \begin{cfa}
 …
 For instance, modularity is generally provided in C by including an opaque forward declaration of a structure and associated accessor and mutator functions in a header file, with the actual implementations in a separately-compiled \texttt{.c} file.
 \CFA{} supports this pattern for generic types, implying that the caller of a polymorphic function may not know the actual layout or size of a dynamic generic type and only holds it by pointer.
 \CFACC{} automatically generates \emph{layout functions} for cases where the size, alignment, and offset array of a generic struct cannot be passed into a function from that function's caller.
+\CFACC{} automatically generates \emph{layout functions} for cases where the size, alignment, and offset array of a generic struct cannot be passed into a function from that functions's caller.
 These layout functions take as arguments pointers to size and alignment variables and a caller-allocated array of member offsets, as well as the size and alignment of all !sized! parameters to the generic structure.
 Un-!sized! parameters are not passed because they are forbidden from being used in a context that affects layout by C's usual rules about incomplete types.
 Similarly, the layout function can only safely be called from a context where the generic type definition is visible, because otherwise the caller does not know how large to allocate the array of member offsets.
 The C standard does not specify a memory layout for structs, but the System V ABI \cite{SysVABI} does; compatibility with this standard is sufficient for \CFA{}'s currently-supported architectures, though future ports may require different layout-function generation algorithms.
+Un!sized! parameters not passed because they are forbidden from being used in a context that affects layout by C's usual rules about incomplete types.
+Similarly, the layout function can only safely be called from a context where the generic type definition is visible, because otherwise the caller will not know how large to allocate the array of member offsets.
+The C standard does not specify a memory layout for structs, but the POSIX ABI for x86\cit{} does; this memory layout is common for C implementations, but is a platform-specific issue for porting \CFA{}.
 This algorithm, sketched below in pseudo-\CFA{}, is a straightforward mapping of consecutive fields into the first properly-aligned offset in the !struct! layout; layout functions for !union! types omit the offset array and simply calculate the maximum size and alignment over all union variants.
 Since \CFACC{} generates a distinct layout function for each type, constant-folding and loop unrolling are applied.
 …
 forall(dtype T1, dtype T2, ... | sized(T1) | sized(T2) | ...)
 void layout(size_t* size, size_t* align, size_t* offsets) {
+        // initialize values
         *size = 0; *align = 1;
         // set up members
 …
 \end{cfa}
 Results of layout-function calls are cached so that they are only computed once per type per function.
 Layout functions also allow generic types to be used in a function definition without reflecting them in the function signature, an important implementation-hiding constraint of the design.
+Results of layout function calls are cached so that they are only computed once per type per function.
+Layout functions also allow generic types to be used in a function definition without reflecting them in the function signature, an important implemenation-hiding constraint of the design.
 For instance, a function that strips duplicate values from an unsorted !list(T)! likely has a reference to the list as its only explicit parameter, but uses some sort of !set(T)! internally to test for duplicate values.
 This function could acquire the layout for !set(T)! by calling its layout function, providing as an argument the layout of !T! implicitly passed into that function.
 Whether a type is concrete, dtype-static, or dynamic is decided solely on the basis of the type arguments and !forall! clause type parameters.
 This design allows opaque forward declarations of generic types, \eg{} !forall(otype T) struct Box;! like in C, all uses of !Box(T)! can be separately compiled, and callers from other translation units know the proper calling conventions.
 In an alternate design, where the definition of a structure type is included in deciding whether a generic type is dynamic or concrete, some further types may be recognized as dtype-static --- \eg{} !Box! could be defined with a body !{ T* p; }!, and would thus not depend on !T! for its layout.
 However, the existence of an !otype! parameter !T! means that !Box! \emph{could} depend on !T! for its layout if this definition is not visible, and preserving separate compilation (and the associated C compatibility) is a more important design metric.
+Whether a type is concrete, dtype-static, or dynamic is decided solely on the basis of the type arguments and !forall! clause type paramters.
+This design allows opaque forward declarations of generic types, \eg{} !forall(otype T) struct Box;! like in C, all uses of $Box(T)$ can be separately compiled, and callers from other translation units know the proper calling conventions to use.
+In an alternate design where the definition of a structure type is included in deciding whether a generic type is dynamic or concrete, some further types may be recognized as dtype-static --- \eg{} !Box! could be defined with a body !{ T* p; }!, and would thus not depend on !T! for its layout.
+However, the existence of an !otype! parameter !T! means that !Box! \emph{could} depend on !T! for its layout if this definition is not visible, and we judged preserving separate compilation (and the associated C compatibility) in the implemented design to be an acceptable trade-off.
 \subsection{Applications of Dtype-static Types} \label{dtype-static-sec}
 …
 Another useful pattern enabled by reused dtype-static type instantiations is zero-cost \emph{tag structures}.
 Sometimes, information is only used for type checking and can be omitted at runtime.
 In the example below, !scalar! is a dtype-static type; hence, all uses have a single structure definition containing !unsigned long! and can share the same implementations of common functions, like !?+?!.
+In the example below, !scalar! is a dtype-static type; hence, all uses have a single structure definition containing !unsigned long! and can share the same implementations of common functions like !?+?!.
 These implementations may even be separately compiled, unlike \CC{} template functions.
 However, the \CFA{} type checker ensures matching types are used by all calls to !?+?!, preventing nonsensical computations like adding a length to a volume.
 …
 \section{Performance Experiments} \label{generic-performance-sec}
 To validate the practicality of this generic type design, microbenchmark-based tests were conducted against a number of comparable code designs in C and \CC{}, first published in \cite{Moss18}.
 Since these languages are all C-based and compiled with the same compiler backend, maximal-performance benchmarks should show little runtime variance, differing only in length and clarity of source code.
+To validate the practicality of this generic type design I have conducted microbenchmark-based tests against a number of comparable code designs in C and \CC{}, first published in \cite{Moss18}.
+Since all these languages are compiled with the same compiler backend and share a subset essentially comprising standard C, maximal-performance benchmarks should show little runtime variance, differing only in length and clarity of source code.
 A more illustrative comparison measures the costs of idiomatic usage of each language's features.
+The code below shows the \CFA{} benchmark tests for a generic stack based on a singly-linked list; the test suite is equivalent for the other languages, code for which is included in Appendix~\ref{generic-bench-app}.
+The experiment uses element types !int! and !pair(short, char)! and pushes $N = 4M$ elements on a generic stack, copies the stack, clears one of the stacks, and finds the maximum value in the other stack.
+\begin{cfa}
+#define N 4000000
+The code below shows the \CFA{} benchmark tests for a generic stack based on a singly-linked list; the test suite is equivalent for the other other languages.
+The experiment uses element types !int! and !pair(short, char)! and pushes $N = 40M$ elements on a generic stack, copies the stack, clears one of the stacks, and finds the maximum value in the other stack.
+\begin{cfa}
 int main() {
         int max = 0, val = 42;
 …
 \end{cfa}
 The four versions of the benchmark implemented are C with !void*!-based polymorphism, \CFA{} with parametric polymorphism, \CC{} with templates, and \CC{} using only class inheritance for polymorphism, denoted \CCV{}.
 The \CCV{} variant illustrates an alternative object-oriented idiom where all objects inherit from a base !object! class, a language design similar to Java 4; in particular, runtime checks are necessary to safely downcast objects.
+The four versions of the benchmark implemented are C with !void*!-based polymorphism, \CFA{} with parameteric polymorphism, \CC{} with templates, and \CC{} using only class inheritance for polymorphism, denoted \CCV{}.
+The \CCV{} variant illustrates an alternative object-oriented idiom where all objects inherit from a base !object! class, mimicking a Java-like interface; in particular, runtime checks are necessary to safely downcast objects.
 The most notable difference among the implementations is the memory layout of generic types: \CFA{} and \CC{} inline the stack and pair elements into corresponding list and pair nodes, while C and \CCV{} lack such capability and, instead, must store generic objects via pointers to separately allocated objects.
 Note that the C benchmark uses unchecked casts as C has no runtime mechanism to perform such checks, whereas \CFA{} and \CC{} provide type safety statically.
 …
 \centering
 \input{generic-timing}
 \caption[Benchmark timing results]{Benchmark timing results (smaller is better)} \label{generic-eval-fig}
+\caption{Benchmark timing results (smaller is better)} \label{generic-eval-fig}
 \end{figure}
 …
 The C and \CCV{} variants are generally the slowest and have the largest memory footprint, due to their less-efficient memory layout and the pointer indirection necessary to implement generic types in those languages; this inefficiency is exacerbated by the second level of generic types in the pair benchmarks.
 By contrast, the \CFA{} and \CC{} variants run in noticeably less time for both the integer and pair because of the equivalent storage layout, with the inlined libraries (\ie{} no separate compilation) and greater maturity of the \CC{} compiler contributing to its lead.
+By contrast, the \CFA{} and \CC{} variants run in roughly equivalent time for both the integer and pair because of the equivalent storage layout, with the inlined libraries (\ie{} no separate compilation) and greater maturity of the \CC{} compiler contributing to its lead.
 \CCV{} is slower than C largely due to the cost of runtime type checking of downcasts (implemented with !dynamic_cast!); the outlier for \CFA{}, pop !pair!, results from the complexity of the generated-C polymorphic code.
 The gcc compiler is unable to optimize some dead code and condense nested calls; a compiler designed for \CFA{} could more easily perform these optimizations.
 Finally, the binary size for \CFA{} is larger because of static linking with the \CFA{} prelude library, which includes function definitions for all the built-in operators.
+Finally, the binary size for \CFA{} is larger because of static linking with \CFA{} libraries.
 \CFA{} is also competitive in terms of source code size, measured as a proxy for programmer effort.
 …
 Use of these standard library types has minimal impact on the performance benchmarks, but shrinks the \CFA{} and \CC{} code to 39 and 42 lines, respectively.
 The difference between the \CFA{} and \CC{} line counts is primarily declaration duplication to implement separate compilation; a header-only \CFA{} library is similar in length to the \CC{} version.
 On the other hand, due to the language shortcomings mentioned at the beginning of the chapter, C does not have a generic collections library in its standard distribution, resulting in frequent re-implementation of such collection types by C programmers.
+On the other hand, due to the language shortcomings mentioned at the beginning of the chapter, C does not have a generic collections library in its standard distribution, resulting in frequent reimplementation of such collection types by C programmers.
 \CCV{} does not use the \CC{} standard template library by construction, and, in fact, includes the definition of !object! and wrapper classes for !char!, !short!, and !int! in its line count, which inflates this count somewhat, as an actual object-oriented language would include these in the standard library.
 I justify the given line count by noting that many object-oriented languages do not allow implementing new interfaces on library types without subclassing or wrapper types, which may be similarly verbose.
 …
 Line count is a fairly rough measure of code complexity; another important factor is how much type information the programmer must specify manually, especially where that information is not type-checked.
 Such unchecked type information produces a heavier documentation burden and increased potential for runtime bugs and is much less common in \CFA{} than C, with its manually specified function pointer arguments and format codes, or \CCV{}, with its extensive use of un-type-checked downcasts, \eg{} !object! to !integer! when popping a stack.
 To quantify this manual typing, the ``redundant type annotations'' line in Table~\ref{generic-eval-table} counts the number of lines on which the known type of a variable is re-specified, either as a format specifier, explicit downcast, type-specific function, or by name in a !sizeof!, !struct! literal, or !new! expression.
+To quantify this manual typing, the ``redundant type annotations'' line in Table~\ref{generic-eval-table} counts the number of lines on which the known type of a variable is respecified, either as a format specifier, explicit downcast, type-specific function, or by name in a !sizeof!, !struct! literal, or !new! expression.
 The \CC{} benchmark uses two redundant type annotations to create new stack nodes, whereas the C and \CCV{} benchmarks have several such annotations spread throughout their code.
 The \CFA{} benchmark is able to eliminate \emph{all} redundant type annotations through use of the return-type polymorphic !alloc! function in the \CFA{} standard library.
 …
 \section{Future Work}
 The generic types presented here are already sufficiently expressive to implement a variety of useful library types.
+The generic types design presented here is already sufficiently expressive to implement a variety of useful library types.
 However, some other features based on this design could further improve \CFA{}.
 The most pressing addition is the ability to have non-type generic parameters.
+C already supports fixed-length array types, \eg{} !int[10]!; these types are essentially generic types with unsigned integer parameters (\ie{} array dimension), and allowing \CFA{} users the capability to build similar types is a requested feature.
+% More exotically, the ability to have these non-type parameters depend on dynamic runtime values rather than static compile-time constants opens up interesting opportunities for type-checking problematic code patterns.
+% For example, if a collection iterator was parameterized over the pointer to the collection it was drawn from, then a sufficiently powerful static analysis pass could ensure that that iterator was only used for that collection, eliminating one source of hard-to-find bugs.
+The implementation mechanisms behind generic types can also be used to add new features to \CFA{}.
+One such potential feature is \emph{field assertions}, an addition to the existing function and variable assertions on polymorphic type variables.
+These assertions could be specified using this proposed syntax:
+\begin{cfa}
+trait hasXY(dtype T) {
+        int T.x;  $\C{// T has a field x of type int}$
+        int T.y;  $\C{// T has a field y of type int}$
+};
+\end{cfa}
+C already supports fixed-length array types, \eg{} !int[10]!; these types are essentially generic types with unsigned integer parameters, and allowing \CFA{} users the capability to build similar types is a requested feature.
+More exotically, the ability to have these non-type parameters depend on dynamic runtime values rather than static compile-time constants opens up interesting opportunities for type-checking problematic code patterns.
+For example, if a collection iterator was parameterized over the pointer to the collection it was drawn from, then a sufficiently powerful static analysis pass could ensure that that iterator was only used for that collection, eliminating one source of hard-to-find bugs.
+The implementation mechanisms behind this generic types design can also be used to add new features to \CFA{}.
+One such potential feature would be to add \emph{field assertions} to the existing function and variable assertions on polymorphic type variables.
 Implementation of these field assertions would be based on the same code that supports member access by dynamic offset calculation for dynamic generic types.
 Simulating field access can already be done more flexibly in \CFA{} by declaring a trait containing an accessor function to be called from polymorphic code, but these accessor functions impose some overhead both to write and call, and directly providing field access via an implicit offset parameter would be both more concise and more efficient.
+Of course, there are language design trade-offs to such an approach, notably that providing the two similar features of field and function assertions would impose a burden of choice on programmers writing traits, with field assertions more efficient, but function assertions more general; given this open design question a decision on field assertions is deferred until \CFA{} is more mature.
+If field assertions are included in the language, a natural extension would be to provide a structural inheritance mechanism for every !struct! type that simply turns the list of !struct! fields into a list of field assertions, allowing monomorphic functions over that type to be generalized to polymorphic functions over other similar types with added or reordered fields, for example:
+\begin{cfa}
+struct point { int x, y; };  $\C{// traitof(point) is equivalent to hasXY above}$
+struct coloured_point { int x, y; enum { RED, BLACK } colour };
+// works for both point and coloured_point
+forall(dtype T | traitof(point)(T) )
+double hypot( T& p ) { return sqrt( p.x*p.x + p.y*p.y ); }
+\end{cfa}
+\CFA{} could also support a packed or otherwise size-optimized representation for generic types based on a similar mechanism --- nothing in the use of the offset arrays implies that the field offsets need to be monotonically increasing.
+Of course, there are language design trade-offs to such an approach, notably that providing the two similar features of field and function assertions would impose a burden of choice on programmers writing traits, with field assertions more efficient, but function assertions more general; given this open design question we have deferred a decision on field assertions until we have more experience using \CFA{}.
+If field assertions are included in the language, a natural extension would be to provide a structural inheritance mechanism for every !struct! type that simply turns the list of !struct! fields into a list of field assertions, allowing monomorphic functions over that type to be generalized to polymorphic functions over other similar types with added or reordered fields.
+\CFA{} could also support a packed or otherwise size-optimized representation for generic types based on a similar mechanism --- the layout function would need to be re-written, but nothing in the use of the offset arrays implies that the field offsets need be monotonically increasing.
 With respect to the broader \CFA{} polymorphism design, the experimental results in Section~\ref{generic-performance-sec} demonstrate that though the runtime impact of \CFA{}'s dynamic virtual dispatch is low, it is not as low as the static dispatch of \CC{} template inlining.
+However, rather than subject all \CFA{} users to the compile-time costs of ubiquitous template expansion, it is better to target performance-sensitive code more precisely.
+Two promising approaches are an !inline! annotation at polymorphic function call sites to create a template specialization of the function (provided the code is visible) or placing a different !inline! annotation on polymorphic function definitions to instantiate a specialized version of the function for some set of types.
+These approaches are complementary and allow performance optimizations to be applied only when necessary, without suffering global code bloat.
+However, rather than subject all \CFA{} users to the compile-time costs of ubiquitous template expansion, we are considering more targeted mechanisms for performance-sensitive code.
+Two promising approaches are are an !inline! annotation at polymorphic function call sites to create a template specialization of the function (provided the code is visible) or placing a different !inline! annotation on polymorphic function definitions to instantiate a specialized version of the function for some set of types.
+These approaches are not mutually exclusive and allow performance optimizations to be applied only when necessary, without suffering global code bloat.
+In general, the \CFA{} team believes that separate compilation works well with loaded hardware caches by producing smaller code, which may offset the benefit of larger inlined code.

doc/theses/aaron_moss_PhD/phd/introduction.tex

-              r933f32f
+              r6a9d4b4
 \chapter{Introduction}
 The C programming language~\cite{C11} has had a wide-ranging impact on the design of software and programming languages.
 In the 30 years since its first standardization, it has consistently been one of the most popular programming languages, with billions of lines of C code still in active use, and tens of thousands of trained programmers producing it. The TIOBE index~\cite{TIOBE} tracks popularity of programming languages over time, and C has never dropped below second place:
+The C programming language has had a wide-ranging impact on the design of software and programming languages.
+In the 30 years since its first standardization, it has consistently been one of the most popular programming languages, with millions of lines of C code still in active use, and tens of thousands of trained programmers producing it. The TIOBE index\cite{TIOBE} tracks popularity of programming languages over time, and C has never dropped below second place:
 \begin{table}[h]
 …
 \end{table}
 The impact of C on programming language design is also obvious from Table~\ref{tiobe-table}; with the exception of Python, all of the top five languages use C-like syntax and control structures.
 \CC{}~\cite{C++} is even a largely backwards-compatible extension of C.
 Though its lasting popularity and wide impact on programming language design point to the continued relevance of C, there is also widespread desire of programmers for languages with more expressive power and programmer-friendly features; accommodating both maintenance of legacy C code and development of the software of the future is a difficult task for a single programming language.
+The impact of C on programming language design is also obvious from Table~\ref{tiobe-table}; with the exception of Python, all of the top five languages use C-like syntax and procedural control structures.
+\CC{} is even a largely backwards-compatible extension of C, with development dating back nearly as far as C itself.
+Though its lasting popularity and wide impact on programming language design point to the continued relevance of C, they also highlight the widespread desire of programmers for languages with more expressive power and programmer-friendly features; accommodating both low-impact maintenance of legacy C code and low-effort development of the software of the future is a difficult task for a single programming language.
 \CFA{}\footnote{Pronounced ``C-for-all'', and written \CFA{} or \CFL{}.} is an evolutionary modernization of the C programming language that aims to fulfill both these ends well.
+\CFA{}\footnote{Pronounced ``C-for-all'', and written \CFA{} or \CFL{}.} is an evolutionary modernization of the C programming language which aims to fulfill both these ends well.
 \CFA{} both fixes existing design problems and adds multiple new features to C, including name overloading, user-defined operators, parametric-polymorphic routines, and type constructors and destructors, among others.
 The new features make \CFA{} more powerful and expressive than C, while maintaining strong backward-compatibility with both C code and the procedural paradigm expected by C programmers.
+Unlike other popular C extensions like \CC{} and Objective-C, \CFA{} adds modern features to C without imposing an object-oriented paradigm to use them.
+However, these new features do impose a compile-time cost, particularly in the expression resolver, which must evaluate the typing rules of a significantly more complex type system.
+However, these new features do impose a compile-time cost, particularly in the expression resolver, which must evaluate the typing rules of a significantly more complex type-system.
 This thesis is focused on making \CFA{} a more powerful and expressive language, both by adding new features to the \CFA{} type system and ensuring that both added and existing features can be efficiently implemented in \CFACC{}, the \CFA{} reference compiler.
+Particular contributions of this work include:
+\begin{itemize}
+\item design and implementation of parametric-polymorphic (``generic'') types in a manner compatible with the existing polymorphism design of \CFA{} (Chapter~\ref{generic-chap}),
+\item a new expression resolution algorithm designed to quickly locate the optimal declarations for a \CFA{} expression (Chapter~\ref{resolution-chap}),
+\item a type environment data structure based on a novel variant of the union-find algorithm (Chapter~\ref{env-chap}),
+\item and as a technical contribution, a prototype system for compiler algorithm development which encapsulates the essential aspects of the \CFA{} type system without incurring the technical debt of the existing system or the friction-inducing necessity of maintaining a working compiler (Chapter~\ref{expr-chap}).
+\end{itemize}
+Particular contributions of this work include design and implementation of
+parametric-polymorphic (``generic'') types in a manner compatible with the existing polymorphism design of \CFA{} (Chapter~\ref{generic-chap}), a type environment data structure based on a novel variant of the union-find algorithm (Chapter~\ref{env-chap}), and a new expression resolution algorithm designed to quickly locate the optimal declarations for a \CFA{} expression (Chapter~\ref{resolution-chap}).
+This expression resolution algorithm was designed with the aid of a purpose-built prototype system which encapsulates the essential aspects of the \CFA{} type system without incurring the technical debt of the existing system or the friction-inducing necessity of maintaining a working compiler; the goal of this prototype system was to discover effective heuristics to avoid performing unnecessary work in the process of locating the optimal \CFA{} expression resolution.
+The prototype system, which implements the algorithmic contributions of this thesis, is the first performant type-checker implementation for a \CFA{}-style type system.
+As the existence of an efficient compiler is necessary for the practical viability of a programming language, the contributions of this thesis comprise a validation of the \CFA{} language design that was previously lacking.
+Though the direction and experimental validation of this work is fairly narrowly focused on the \CFA{} programming language, the tools used and results obtained should be of interest to a wider compiler and programming language design community.
+In particular, with the addition of \emph{concepts} in \CCtwenty{}~\cite{C++Concepts}, conforming \CC{} compilers must support a model of type assertions very similar to that in \CFA{}, and the algorithmic techniques used here may prove useful.
+Much of the difficulty of type-checking \CFA{} stems from the language design choice to allow overload selection from the context of a function call based on function return type in addition to the type of the arguments to the call; this feature allows the programmer to specify fewer redundant type annotations on functions that are polymorphic in their return type.
+As an example in \CC{}:
+\begin{C++}
+template<typename T> T* zero() { return new T( 0 ); }
+int* z = zero<int>();  $\C{// must specify int twice}$
+\end{C++}
+\CFA{} allows !int* z = zero()!, which elides the second !int!.
+While the !auto! keyword in \CCeleven{} supports similar inference in a limited set of contexts (\eg{} !auto z = zero<int>()!), the demonstration of the richer inference in \CFA{} raises possibilities for similar features in future versions of \CC{}.
+By contrast to \CC{}, Java~8~\cite{Java8} and Scala~\cite{Scala} use comparably powerful forms of type inference to \CFA{}, so the algorithmic techniques in this thesis may be effective for those languages' compiler implementors.
+Type environments are also widely modelled in compiler implementations, particularly for functional languages, though also increasingly commonly for other languages (such as Rust~\cite{Rust}) that perform type inference; the type environment presented here may be useful to those language implementors.
+One area of inquiry that is outside the scope of this thesis is formalization of the \CFA{} type system.
+Ditchfield~\cite{Ditchfield92} defined the $F_\omega^\ni$ polymorphic lambda calculus, which is the theoretical basis for the \CFA{} type system.
+Ditchfield did not, however, prove any soundness or completeness properties for $F_\omega^\ni$; such proofs remain future work.
+A number of formalisms other than $F_\omega^\ni$ could potentially be adapted to model \CFA{}.
+One promising candidate is \emph{local type inference} \cite{Pierce00,Odersky01}, which describes similar contextual propagation of type information; another is the polymorphic conformity-based model of the Emerald~\cite{Black90} programming language, which defines a subtyping relation on types that is conceptually similar to \CFA{} traits.
+These modelling approaches could potentially be used to extend an existing formal semantics for C such as Cholera \cite{Norrish98}, CompCert \cite{Leroy09}, or Formalin \cite{Krebbers14}.
+Though the direction and validation of this work was fairly narrowly focused on the \CFA{} programming language, the tools used and results obtained should be of interest to a wider compiler and programming language design community.
+In particular, with the addition of \emph{concepts} in \CCtwenty{}, conforming \CC{} compilers must support a model of type assertions very similar to that in \CFA{}, and the algorithmic techniques used in the expression resolution algorithm presented here may prove useful.
+Type environments are also widely modelled in compiler implementations, particularly of functional languages, though also increasingly commonly in other languages (such as Rust) which perform type inference; the type environment presented here may be useful to those language implementers.

doc/theses/aaron_moss_PhD/phd/macros.tex

-              r933f32f
+              r6a9d4b4
 \newcommand{\Csharp}{C\raisebox{-0.7ex}{\Large$^\sharp$}} % C# symbolic name
+\newcommand{\ie}{\textit{i.e.}\@}
+\newcommand{\eg}{\textit{e.g.}\@}
+\newcommand{\etc}{\textit{etc.}\@}
+\newcommand{\etal}{\textit{et~al.}\@}
+\newcommand{\vs}{\textit{vs.}\@}
+\newcommand{\ie}{\textit{i.e.}}
+\newcommand{\eg}{\textit{e.g.}}
+\newcommand{\etc}{\textit{etc.}}
+\newcommand{\etal}{\textit{et~al.}}
 \newcommand{\myset}[1]{\left\{#1\right\}}

doc/theses/aaron_moss_PhD/phd/resolution-heuristics.tex

-              r933f32f
+              r6a9d4b4
 \chapter{Resolution Algorithms}
+\chapter{Resolution Heuristics}
 \label{resolution-chap}
+The main task of the \CFACC{} type-checker is \emph{expression resolution}: determining which declarations the identifiers in each expression correspond to.
+Resolution is a straightforward task in C, as no simultaneously-visible declarations share identifiers, but in \CFA{}, the name overloading features discussed in Section~\ref{overloading-sec} generate multiple candidate declarations for each identifier.
+A given matching between identifiers and declarations in an expression is an \emph{interpretation}; an interpretation also includes information about polymorphic type bindings and implicit casts to support the \CFA{} features discussed in Sections~\ref{poly-func-sec} and~\ref{implicit-conv-sec}, each of which increase the number of valid candidate interpretations.
+To choose among valid interpretations, a \emph{conversion cost} is used to rank interpretations.
+This conversion cost is summed over all subexpression interpretations in the interpretation of a top-level expression.
+Hence, the expression resolution problem is to find the unique minimal-cost interpretation for an expression, reporting an error if no such unique interpretation exists.
+The main task of the \CFACC{} type-checker is \emph{expression resolution}, determining which declarations the identifiers in each expression correspond to.
+Resolution is a straightforward task in C, as each declaration has a unique identifier, but in \CFA{} the name overloading features discussed in Section~\ref{overloading-sec} generate multiple candidate declarations for each identifier.
+I refer to a given matching between identifiers and declarations in an expression as an \emph{interpretation}; an interpretation also includes information about polymorphic type bindings and implicit casts to support the \CFA{} features discussed in Sections~\ref{poly-func-sec} and~\ref{implicit-conv-sec}, each of which increase the proportion of feasible candidate interpretations.
+To choose between feasible interpretations, \CFA{} defines a \emph{conversion cost} to rank interpretations; the expression resolution problem is thus to find the unique minimal-cost interpretation for an expression, reporting an error if no such interpretation exists.
 \section{Expression Resolution}
+\section{Conversion Cost}
-The expression resolution pass in \CFACC{} must traverse an input expression, match identifiers to available declarations, rank candidate interpretations according to their conversion cost, and check type assertion satisfaction for these candidates.
-Once the set of valid interpretations for the top-level expression is found, the expression resolver selects the unique minimal-cost candidate or reports an error.
-The expression resolution problem in \CFA{} is more difficult than the analogous problems in C or \CC{}.
-As mentioned above, the lack of name overloading in C (except for built-in operators) makes its resolution problem substantially easier.
-A comparison of the richer type systems in \CFA{} and \CC{} highlights some of the challenges in \CFA{} expression resolution.
-The key distinction between \CFA{} and \CC{} resolution is that \CC{} uses a greedy algorithm for selection of candidate functions given their argument interpretations, whereas \CFA{} allows contextual information from superexpressions to influence the choice among candidate functions.
-One key use of this contextual information is for type inference of polymorphic return types; \CC{} requires explicit specification of template parameters that only occur in a function's return type, while \CFA{} allows the instantiation of these type parameters to be inferred from context (and in fact does not allow explicit specification of type parameters to a function), as in the following example:
+\begin{cfa}
+forall(dtype T) T& deref(T*); $\C{// dereferences pointer}$
+forall(otype T) T* def(); $\C{// new heap-allocated default-initialized value}$
+% Discuss changes to cost model, as promised in Ch. 2
+int& i = deref( def() );
+\end{cfa}
+In this example, the \CFA{} compiler infers the type arguments of !deref! and !def! from the !int&! type of !i!; \CC{}, by contrast, requires a type parameter on !def!\footnote{The type parameter of \lstinline{deref} can be inferred from its argument.}, \ie{} !deref( def<int>() )!.
+Similarly, while both \CFA{} and \CC{} rank candidate functions based on a cost metric for implicit conversions, \CFA{} allows a suboptimal subexpression interpretation to be selected if it allows a lower-cost overall interpretation, while \CC{} requires that each subexpression interpretation have minimal cost.
+Because of this use of contextual information, the \CFA{} expression resolver must consider multiple interpretations of each function argument, while the \CC{} compiler has only a single interpretation for each argument\footnote{With the exception of address-of operations on functions.}.
+Additionally, until the introduction of concepts in \CCtwenty{} \cite{C++Concepts}, \CC{} expression resolution has no analogue to \CFA{} assertion satisfaction checking, a further  complication for a \CFA{} compiler.
+The precise definition of \CFA{} expression resolution in this section further expands on the challenges of this problem.
+\subsection{Type Unification}
+The polymorphism features of \CFA{} require binding of concrete types to polymorphic type variables.
+Briefly, \CFACC{} keeps a mapping from type variables to the concrete types they are bound to as an auxiliary data structure during expression resolution; Chapter~\ref{env-chap} describes this \emph{environment} data structure in more detail.
+A \emph{unification} algorithm is used to simultaneously check two types for equivalence with respect to the substitutions in an environment and update that environment.
+Essentially, unification recursively traverses the structure of both types, checking them for equivalence, and when it encounters a type variable, it replaces it with the concrete type it is bound to; if the type variable has not yet been bound, the unification algorithm assigns the equivalent type as the bound type of the variable, after performing various consistency checks.
+Ditchfield~\cite{Ditchfield92} and Bilson~\cite{Bilson03} describe the semantics of \CFA{} unification in more detail.
+\subsection{Conversion Cost} \label{conv-cost-sec}
+\CFA{}, like C, allows inexact matches between the type of function parameters and function call arguments.
+Both languages insert \emph{implicit conversions} in these situations to produce an exact type match, and \CFA{} also uses the relative \emph{cost} of different conversions to select among overloaded function candidates.
+C does not have an explicit cost model for implicit conversions, but the ``usual arithmetic conversions'' \cite[\S{}6.3.1.8]{C11} used to decide which arithmetic operators to apply define one implicitly.
+The only context in which C has name overloading is the arithmetic operators, and the usual arithmetic conversions define a \emph{common type} for mixed-type arguments to binary arithmetic operators.
+Since for backward-compatibility purposes the conversion costs of \CFA{} must produce an equivalent result to these common type rules, it is appropriate to summarize \cite[\S{}6.3.1.8]{C11} here:
+\begin{itemize}
+\item If either operand is a floating-point type, the common type is the size of the largest floating-point type. If either operand is !_Complex!, the common type is also \linebreak !_Complex!.
+\item If both operands are of integral type, the common type has the same size\footnote{Technically, the C standard defines a notion of \emph{rank} in \cite[\S{}6.3.1.1]{C11}, a distinct value for each \lstinline{signed} and \lstinline{unsigned} pair; integral types of the same size thus may have distinct ranks. For instance, though \lstinline{int} and \lstinline{long} may have the same size, \lstinline{long} always has greater rank. The standard-defined types are declared to have greater rank than any types of the same size added as compiler extensions.} as the larger type.
+\item If the operands have opposite signedness, the common type is !signed! if the !signed! operand is strictly larger, or !unsigned! otherwise. If the operands have the same signedness, the common type shares it.
+\end{itemize}
+Beginning with the work of Bilson~\cite{Bilson03}, \CFA{} defines a \emph{conversion cost} for each function call in a way that generalizes C's conversion rules.
+Loosely defined, the conversion cost counts the implicit conversions utilized by an interpretation.
+With more specificity, the cost is a lexicographically-ordered tuple, where each element corresponds to a particular kind of conversion.
+In Bilson's design, conversion cost is a 3-tuple, $(unsafe, poly, safe)$, where $unsafe$ is the count of unsafe (narrowing) conversions, $poly$ is the count of polymorphic type bindings, and $safe$ is the sum of the degree of safe (widening) conversions.
+Degree of safe conversion is calculated as path weight in a directed graph of safe conversions between types; Bilson's version of this graph is in Figure~\ref{bilson-conv-fig}.
+The safe conversion graph is designed such that the common type $c$ of two types $u$ and $v$ is compatible with the C standard definitions from \cite[\S{}6.3.1.8]{C11} and can be calculated as the unique type minimizing the sum of the path weights of $\overrightarrow{uc}$ and $\overrightarrow{vc}$.
+The following example lists the cost in the Bilson model of calling each of the following functions with two !int! parameters, where the interpretation with the minimum total cost will be selected:
+\begin{cfa}
+void f$\(_1\)$(char, long); $\C{// (1,0,1)}$
+void f$\(_2\)$(short, long); $\C{// (1,0,1)}$
+forall(otype T) void f$\(_3\)$(T, long); $\C{// (0,1,1)}$
+void f$\(_4\)$(long, long); $\C{// (0,0,2)}$
+void f$\(_5\)$(int, unsigned long); $\C{// (0,0,2)}$
+void f$\(_6\)$(int, long); $\C{// (0,0,1)}$
+\end{cfa}
+Note that safe and unsafe conversions are handled differently; \CFA{} counts distance of safe conversions (\eg{} !int! to !long! is cheaper than !int! to !unsigned long!), while only counting the number of unsafe conversions (\eg{} !int! to !char! and !int! to !short! both have unsafe cost 1, as in !f!$_1$ and !f!$_2$ above).
+These costs are summed over the parameters in a call; in the example above, the cost of the two !int! to !long! conversions for !f!$_4$ sum equal to the one !int! to !unsigned long! conversion for !f!$_5$.
+\begin{figure}
+        \centering
+        \begin{subfigure}[h]{3in}
+                \includegraphics{figures/bilson-conv-graph}
+                \caption{Bilson} \label{bilson-conv-fig}
+        \end{subfigure}~\begin{subfigure}[h]{3in}
+                \includegraphics{figures/extended-conv-graph}
+                \caption{Extended} \label{extended-conv-fig}
+        \end{subfigure}
+        % \includegraphics{figures/safe-conv-graph}
+        \caption[Safe conversion graphs.]{Safe conversion graphs. In both graphs, plain arcs have cost $safe = 1, sign = 0$ while dashed sign-conversion arcs have cost $safe = 1, sign = 1$. As per \cite[\S{}6.3.1.8]{C11}, types promote to types of the same signedness with greater rank, from \lstinline{signed} to \lstinline{unsigned} with the same rank, and from \lstinline{unsigned} to \lstinline{signed} with greater size. The arc from \lstinline{unsigned long} to \lstinline{long long} (highlighted in red in \ref{bilson-conv-fig}) is deliberately omitted in \ref{extended-conv-fig}, as on the presented system \lstinline{sizeof(long) == sizeof(long long)}.}
+        \label{safe-conv-fig}
+\end{figure}
+As part of adding reference types to \CFA{} (see Section~\ref{type-features-sec}), Schluntz added a new $reference$ element to the cost tuple, which counts the number of implicit reference-to-rvalue conversions performed so that candidate interpretations can be distinguished by how closely they match the nesting of reference types; since references are meant to act almost indistinguishably from lvalues, this $reference$ element is the least significant in the lexicographic comparison of cost tuples.
+I also refined the \CFA{} cost model as part of this thesis work.
+Bilson's \CFA{} cost model includes the cost of polymorphic type bindings from a function's type assertions in the $poly$ element of the cost tuple; this has the effect of making more-constrained functions more expensive than less-constrained functions, as in the following example, based on differing iterator types:
+\begin{cfa}
+forall(dtype T | { T& ++?(T&); }) T& advance$\(_1\)$(T& i, int n);
+forall(dtype T | { T& ++?(T&); T& ?+=?(T&, int)}) T& advance$\(_2\)$(T& i, int n);
+\end{cfa}
+In resolving a call to !advance!, the binding to the !T&! parameter in the assertions is added to the $poly$ cost in Bilson's model.
+However, type assertions actually make a function \emph{less} polymorphic, and as such functions with more type assertions should be preferred in type resolution.
+In the example above, if the meaning of !advance! is ``increment !i! !n! times'', !advance!$_1$ requires an !n!-iteration loop, while !advance!$_2$ can be implemented more efficiently with the !?+=?! operator; as such, !advance!$_2$ should be chosen over !advance!$_1$ whenever its added constraint can be satisfied.
+Accordingly, a $specialization$ element is now included in the \CFA{} cost tuple, the values of which are always negative.
+Each type assertion subtracts 1 from $specialization$, so that more-constrained functions cost less, and thus are chosen over less-constrained functions, all else being equal.
+A more sophisticated design would define a partial order over sets of type assertions by set inclusion (\ie{} one function would only cost less than another if it had a strict superset of assertions,  rather than just more total assertions), but I did not judge the added complexity of computing and testing this order to be worth the gain in specificity.
+I also incorporated an unimplemented aspect of Ditchfield's earlier cost model.
+In the example below, adapted from \cite[p.89]{Ditchfield92}, Bilson's cost model only distinguished between the first two cases by accounting extra cost for the extra set of !otype! parameters, which, as discussed above, is not a desirable solution:
+\begin{cfa}
+forall(otype T, otype U) void f$\(_1\)$(T, U);  $\C[3.125in]{// polymorphic}$
+forall(otype T) void f$\(_2\)$(T, T);  $\C[3.125in]{// less polymorphic}$
+forall(otype T) void f$\(_3\)$(T, int);  $\C[3.125in]{// even less polymorphic}$
+forall(otype T) void f$\(_4\)$(T*, int); $\C[3.125in]{// least polymorphic}$
+\end{cfa}
+The new cost model accounts for the fact that functions with more polymorphic variables are less constrained by introducing a $var$ cost element that counts the number of type variables on a candidate function.
+In the example above, !f!$_1$ has $var = 2$, while the others have $var = 1$.
+The new cost model also accounts for a nuance unhandled by Ditchfield or Bilson, in that it makes the more specific !f!$_4$ cheaper than the more generic !f!$_3$; !f!$_4$ is presumably somewhat optimized for handling pointers, but the prior \CFA{} cost model could not account for the more specific binding, as it simply counted the number of polymorphic unifications.
+In the modified model, each level of constraint on a polymorphic type in the parameter list results in a decrement of the $specialization$ cost element, which is shared with the count of assertions due to their common nature as constraints on polymorphic type bindings.
+Thus, all else equal, if both a binding to !T! and a binding to !T*! are available, the model chooses the more specific !T*! binding with $specialization = -1$.
+This process is recursive, such that !T**! has $specialization = -2$.
+This calculation works similarly for generic types, \eg{} !box(T)! also has specialization cost $-1$.
+For multi-argument generic types, the least-specialized polymorphic parameter sets the specialization cost, \eg{} the specialization cost of !pair(T, S*)! is $-1$ (from !T!) rather than $-2$ (from !S!).
+Specialization cost is not counted on the return type list; since $specialization$ is a property of the function declaration, a lower specialization cost prioritizes one declaration over another.
+User programmers can choose between functions with varying parameter lists by adjusting the arguments, but the same is not true in general of varying return types\footnote{In particular, as described in Section~\ref{expr-cost-sec}, cast expressions take the cheapest valid and convertible interpretation of the argument expression, and expressions are resolved as a cast to \lstinline{void}. As a result of this, including return types in the $specialization$ cost means that a function with return type \lstinline{T*} for some polymorphic type \lstinline{T} would \emph{always} be chosen over a function with the same parameter types returning \lstinline{void}, even for \lstinline{void} contexts, an unacceptably counter-intuitive result.}, so the return types are omitted from the $specialization$ element.
+Since both $vars$ and $specialization$ are properties of the declaration rather than any particular interpretation, they are prioritized less than the interpretation-specific conversion costs from Bilson's original 3-tuple.
+A final refinement I have made to the \CFA{} cost model is with regard to choosing among arithmetic conversions.
+The C standard \cite[\S{}6.3.1.8]{C11} states that the common type of !int! and !unsigned int! is !unsigned int! and that the common type of !int! and !long! is !long!, but does not provide guidance for making a choice among conversions.
+Bilson's \CFACC{} uses conversion costs based off Figure~\ref{bilson-conv-fig}.
+However, Bilson's design results in inconsistent and somewhat surprising costs, with conversion to the next-larger same-sign type generally (but not always) double the cost of conversion to the !unsigned! type of the same size.
+In the redesign, for consistency with the approach of the usual arithmetic conversions, which select a common type primarily based on size, but secondarily on sign, arcs in the new graph are annotated with whether they represent a sign change, and such sign changes are summed in a new $sign$ cost element that lexicographically succeeds $safe$.
+This means that sign conversions are approximately the same cost as widening conversions, but slightly more expensive (as opposed to less expensive in Bilson's graph), so maintaining the same signedness is consistently favoured.
+This refined conversion graph is shown in Figure~\ref{extended-conv-fig}.
+With these modifications, the current \CFA{} cost tuple is as follows:
+\begin{equation*}
+        (unsafe, poly, safe, sign, vars, specialization, reference)
+\end{equation*}
+\subsection{Expression Cost} \label{expr-cost-sec}
+The mapping from \CFA{} expressions to cost tuples is described by Bilson in \cite{Bilson03}, and remains effectively unchanged with the exception of the refinements to the cost tuple described above.
+Nonetheless, some salient details are repeated here for the sake of completeness.
+On a theoretical level, the resolver treats most expressions as if they were function calls.
+Operators in \CFA{} (both those existing in C and added features like constructors) are all modelled as function calls.
+In terms of the core argument-parameter matching algorithm, overloaded variables are handled the same as zero-argument function calls, aside from a different pool of candidate declarations and setup for different code generation.
+Similarly, an aggregate member expression !a.m! can be modelled as a unary function !m! that takes one argument of the aggregate type.
+Literals do not require sophisticated resolution, as in C the syntactic form of each implies their result types: !42! is !int!, !"hello"! is !char*!, \etc{}\footnote{Struct literals (\eg{} \lstinline|(S)\{ 1, 2, 3 \}| for some struct \lstinline{S}) are a somewhat special case, as they are known to be of type \lstinline{S}, but require resolution of the implied constructor call described in Section~\ref{ctor-sec}.}.
+Since most expressions can be treated as function calls, nested function calls are the primary component of complexity in expression resolution.
+Each function call has an \emph{identifier} that must match the name of the corresponding declaration, and a possibly-empty list of \emph{arguments}.
+These arguments may be function call expressions themselves, producing a tree of function-call expressions to resolve, where the leaf expressions are generally nullary functions, variable expressions, or literals.
+A single instance of expression resolution consists of matching declarations to all the identifiers in the expression tree of a top-level expression, along with inserting any conversions and satisfying all assertions necessary for that matching.
+The cost of a function-call expression is the sum of the conversion costs of each argument type to the corresponding parameter and the total cost of each subexpression, recursively calculated.
+\CFA{} expression resolution must produce either the unique lowest-cost interpretation of the top-level expression, or an appropriate error message if none exists.
+The cost model of \CFA{} precludes a greedy bottom-up resolution pass, as constraints and costs introduced by calls higher in the expression tree can change the interpretation of those lower in the tree, as in the following example:
+\begin{cfa}
+void f(int);
+double g$\(_1\)$(int);
+int g$\(_2\)$(long);
+f( g(42) );
+\end{cfa}
+Considered independently, !g!$_1$!(42)! is the cheapest interpretation of !g(42)!, with cost $(0,0,0,0,0,0,0)$ since the argument type is an exact match.
+However, in context, an unsafe conversion is required to downcast the return type of !g!$_1$ to an !int! suitable for !f!, for a total cost of $(1,0,0,0,0,0,0)$ for !f( g!$_1$!(42) )!.
+If !g!$_2$ is chosen, on the other hand, there is a safe upcast from the !int! type of !42! to !long!, but no cast on the return of !g!$_2$, for a total cost of $(0,0,1,0,0,0,0)$ for !f( g!$_2$!(42) )!; as this is cheaper, !g!$_2$ is chosen.
+Due to this design, all valid interpretations of subexpressions must in general be propagated to the top of the expression tree before any can be eliminated, a lazy form of expression resolution, as opposed to the eager expression resolution allowed by C or \CC{}, where each expression can be resolved given only the resolution of its immediate subexpressions.
+If there are no valid interpretations of the top-level expression, expression resolution fails and must produce an appropriate error message.
+If any subexpression has no valid interpretations, the process can be short-circuited and the error produced at that time.
+If there are multiple valid interpretations of a top-level expression, ties are broken based on the conversion cost, calculated as above.
+If there are multiple minimal-cost valid interpretations of a top-level expression, that expression is said to be \emph{ambiguous}, and an error must be produced.
+Multiple minimal-cost interpretations of a subexpression do not necessarily imply an ambiguous top-level expression, however, as the subexpression interpretations may be disambiguated based on their return type or by selecting a more-expensive interpretation of that subexpression to reduce the overall expression cost, as in the example above.
+The \CFA{} resolver uses type assertions to filter out otherwise-valid subexpression interpretations.
+An interpretation can only be selected if all the type assertions in the !forall! clause on the corresponding declaration can be satisfied with a unique minimal-cost set of satisfying declarations.
+Type assertion satisfaction is tested by performing type unification on the type of the assertion and the type of the declaration satisfying the assertion.
+That is, a declaration that satisfies a type assertion must have the same name and type as the assertion after applying the substitutions in the type environment.
+Assertion-satisfying declarations may be polymorphic functions with assertions of their own that must be satisfied recursively.
+This recursive assertion satisfaction has the potential to introduce infinite loops into the type resolution algorithm, a situation which \CFACC{} avoids by imposing a hard limit on the depth of recursive assertion satisfaction (currently 4); this approach is also taken by \CC{} to prevent infinite recursion in template expansion, and has proven to be effective and not unduly restrictive of the expressive power of \CFA{}.
+Cast expressions must be treated somewhat differently than functions for backwards compatibility purposes with C.
+In C, cast expressions can serve two purposes, \emph{conversion} (\eg{} !(int)3.14!), which semantically converts a value to another value in a different type with a different bit representation, or \emph{coercion} (\eg{} !void* p; (int*)p;!), which assigns a different type to the same bit value.
+C provides a set of built-in conversions and coercions, and user programmers are able to force a coercion over a conversion if desired by casting pointers.
+The overloading features in \CFA{} introduce a third cast semantic, \emph{ascription} (\eg{} !int x; double x; (int)x;!), which selects the overload that most-closely matches the cast type.
+However, since ascription does not exist in C due to the lack of overloadable identifiers, if a cast argument has an unambiguous interpretation as a conversion argument then it must be interpreted as such, even if the ascription interpretation would have a lower overall cost.
+This is demonstrated in the following example, adapted from the C standard library:
+\begin{cfa}
+unsigned long long x;
+(unsigned)(x >> 32);
+\end{cfa}
+In C semantics, this example is unambiguously upcasting !32! to !unsigned long long!, performing the shift, then downcasting the result to !unsigned!, at cost $(1,0,3,1,0,0,0)$.
+If ascription were allowed to be a first-class interpretation of a cast expression, it would be cheaper to select the !unsigned! interpretation of !?>>?! by downcasting !x! to !unsigned! and upcasting !32! to !unsigned!, at a total cost of $(1,0,1,1,0,0,0)$.
+However, this break from C semantics is not backwards compatible, so to maintain C compatibility, the \CFA{} resolver selects the lowest-cost interpretation of the cast argument for which a conversion or coercion to the target type exists (upcasting to !unsigned long long! in the example above, due to the lack of unsafe downcasts), using the cost of the conversion itself only as a tie-breaker.
+For example, in !int x; double x; (int)x;!, both declarations have zero-cost interpretations as !x!, but the !int x! interpretation is cheaper to cast to !int!, and is thus selected.
+Thus, in contrast to the lazy resolution of nested function-call expressions discussed above, where final interpretations for each subexpression are not chosen until the top-level expression is reached, cast expressions introduce eager resolution of their argument subexpressions, as if that argument was itself a top-level expression.
+\section{Resolution Algorithms}
+\CFA{} expression resolution is not, in general, polynomial in the size of the input expression, as shown in Section~\ref{resn-analysis-sec}.
+While this theoretical result is daunting, its implications can be mitigated in practice.
+\CFACC{} does not solve one instance of expression resolution in the course of compiling a program, but rather thousands; therefore, if the worst case of expression resolution is sufficiently rare, worst-case instances can be amortized by more-common easy instances for an acceptable overall runtime, as shown in Section~\ref{instance-expr-sec}.
+Secondly, while a programmer \emph{can} deliberately generate a program designed for inefficient compilation\footnote{See for instance \cite{Haberman16}, which generates arbitrarily large \CC{} template expansions from a fixed-size source file.}, source code tends to follow common patterns.
+Programmers generally do not want to run the full compiler algorithm in their heads, and as such keep mental shortcuts in the form of language idioms.
+If the compiler can be tuned to handle idiomatic code more efficiently, then the reduction in runtime for idiomatic (but otherwise difficult) resolution instances can make a significant difference in total compiler runtime.
+\subsection{Worst-case Analysis} \label{resn-analysis-sec}
+Expression resolution has a number of components that contribute to its runtime, including argument-parameter type unification, recursive traversal of the expression tree, and satisfaction of type assertions.
+If the bound type for a type variable can be looked up or mutated in constant time (as asserted in Table~\ref{env-bounds-table}), then the runtime of the unification algorithm to match an argument to a parameter is usually proportional to the complexity of the types being unified.
+In C, complexity of type representation is bounded by the most-complex type explicitly written in a declaration, effectively a small constant; in \CFA{}, however, polymorphism can generate more-complex types:
+\begin{cfa}
+        forall(otype T) pair(T) wrap(T x, T y);
+        wrap(wrap(wrap(1, 2), wrap(3, 4)), wrap(wrap(5, 6), wrap(7, 8)));
+\end{cfa}
+To resolve the outermost !wrap!, the resolver must check that !pair(pair(int))! unifies with itself, but at three levels of nesting, !pair(pair(int))! is more complex than either !pair(T)! or !T!, the types in the declaration of !wrap!.
+Accordingly, the cost of a single argument-parameter unification is $O(d)$, where $d$ is the depth of the expression tree, and the cost of argument-parameter unification for a single candidate for a given function call expression is $O(pd)$, where $p$ is the number of parameters.
+This bound does not, however, account for the higher costs of unifying two polymorphic type variables, which may in the worst case result in a recursive unification of all type variables in the expression (as discussed in Chapter~\ref{env-chap}).
+Since this recursive unification reduces the number of type variables, it may happen at most once, for an added $O(p^d)$ cost for a top-level expression with $O(p^d)$ type variables.
+Implicit conversions are also checked in argument-parameter matching, but the cost of checking for the existence of an implicit conversion is again proportional to the complexity of the type, $O(d)$.
+Polymorphism also introduces a potential expense here; for a monomorphic function there is only one potential implicit conversion from argument type to parameter type, while if the parameter type is an unbound polymorphic type-variable then any implicit conversion from the argument type could potentially be considered a valid binding for that type variable.
+\CFA{}, however, requires exact matches for the bound type of polymorphic parameters, removing this problem.
+An interesting question for future work is whether loosening this requirement incurs a significant compiler runtime cost in practice; preliminary results from the prototype system described in Chapter~\ref{expr-chap} suggest it does not.
+Considering the recursive traversal of the expression tree, polymorphism again greatly expands the worst-case runtime.
+Let $i$ be the number of candidate declarations for each function call; if all of these candidates are monomorphic, then there are no more than $i$ unambiguous interpretations of the subexpression rooted at that function call.
+Ambiguous minimal-cost subexpression interpretations may also be collapsed into a single \emph{ambiguous interpretation}, as the presence of such a subexpression interpretation in the final solution is an error condition.
+One safe pruning operation during expression resolution is to discard all subexpression interpretations with greater-than-minimal cost for their return type, as such interpretations cannot beat the minimal-cost interpretation with their return type for the overall optimal solution.
+As such, with no polymorphism, each declaration can generate no more than one minimal-cost interpretation with its return type, so the number of possible subexpression interpretations is $O(i)$ (note that in C, which lacks overloading, $i \leq 1$).
+With polymorphism, however, a single declaration (like !wrap! above) can have many concrete return types after type variable substitution, and could in principle have a different concrete return type for each combination of argument interpretations.
+Calculated recursively, the bound on the total number of candidate interpretations is $O(i^{p^d})$, each with a distinct type.
+Given these calculations of number of subexpression interpretations and matching costs, the upper bound on runtime for generating candidates for a single subexpression $d$ levels up from the leaves is $O( i^{p^d} \cdot pd )$.
+Since there are $O(p^d)$ subexpressions in a single top-level expression, the total worst-case cost of argument-parameter matching with the overloading and polymorphism features of \CFA{} is $O( i^{p^d} \cdot pd \cdot p^d )$.
+Since the size of the expression is $O(p^d)$, letting $n = p^d$ this simplifies to $O(i^n \cdot n^2)$
+This bound does not yet account for the cost of assertion satisfaction, however.
+\CFA{} uses type unification on the assertion type and the candidate declaration type to test assertion satisfaction; this unification calculation has cost proportional to the complexity of the declaration type after substitution of bound type variables; as discussed above, this cost is $O(d)$.
+If there are $O(a)$ type assertions on each declaration, there are $O(i)$ candidates to satisfy each assertion, for a total of $O(ai)$ candidates to check for each declaration.
+However, each assertion candidate may generate another $O(a)$ assertions, recursively until the assertion recursion limit $r$ is reached, for a total cost of $O((ai)^r \cdot d)$.
+Now, $a$ and $i$ are properties of the set of declarations in scope, while $r$ is defined by the language spec, so $(ai)^r$ is essentially a constant for purposes of expression resolution, albeit a very large one.
+It is not uncommon in \CFA{} to have functions with dozens of assertions, and common function names (\eg{} !?{}!, the constructor) can have hundreds of overloads.
+It is clear that assertion satisfaction costs can be very large, and in fact a method for heuristically reducing these costs is one of the key contributions of this thesis, but it should be noted that the worst-case analysis is a particularly poor match for actual code in the case of assertions.
+It is reasonable to assume that most code compiles without errors, as an actively-developed project is compiled many times, generally with relatively few new errors introduced between compiles.
+However, the worst-case bound for assertion satisfaction is based on recursive assertion satisfaction calls exceeding the limit, which is an error case.
+In practice, then, the depth of recursive assertion satisfaction should be bounded by a small constant for error-free code, which accounts for the vast majority of problem instances.
+Similarly, uses of polymorphism like those that generate the $O(d)$ bound on unification or the $O(i^{p^d})$ bound on number of candidates are rare, but not completely absent.
+This analysis points to type unification, argument-parameter matching, and assertion satisfaction as potentially costly elements of expression resolution, and thus profitable targets for algorithmic investigation.
+Type unification is discussed in Chapter~\ref{env-chap}, while the other aspects are covered below.
+\subsection{Argument-Parameter Matching} \label{arg-parm-matching-sec}
+Pruning possible interpretations as early as possible is one way to reduce the real-world cost of expression resolution, provided that a sufficient proportion of interpretations are pruned to pay for the cost of the pruning algorithm.
+One opportunity for interpretation pruning is by the argument-parameter type matching, but the literature \cite{Baker82,Bilson03,Cormack81,Ganzinger80,Pennello80,PW:overload} provides no clear answers on whether candidate functions should be chosen according to their available arguments, or whether argument resolution should be driven by the available function candidates.
+For programming languages without implicit conversions, argument-parameter matching is essentially the entirety of the expression resolution problem, and is generally referred to as ``overload resolution'' in the literature.
+All expression-resolution algorithms form a DAG of interpretations, some explicitly, some implicitly; in this DAG, arcs point from function-call interpretations to argument interpretations, as in Figure~\ref{res-dag-fig}
+\begin{figure}[h]
+        \centering
+        \begin{subfigure}[h]{3in}
+        \begin{cfa}
+        char *p$\(_1\)$;
+        int *p$\(_2\)$;
+        char *f$\(_1\)$(char*, int*);
+        double *f$\(_2\)$(int*, int*);
+        f$\(_A\)$( f$\(_B\)$( p$\(_A\)$, p$\(_B\)$ ), p$\(_C\)$ );
+        \end{cfa}
+        \end{subfigure}~\begin{subfigure}[h]{2.5in}
+        \includegraphics{figures/resolution-dag}
+        \end{subfigure}
+        \caption[Resolution DAG for a simple expression.]{Resolution DAG for a simple expression, annotated with explanatory subscripts. Functions that do not have a valid argument matching are covered with an \textsf{X}.} \label{res-dag-fig}
+\end{figure}
+Note that some interpretations may be part of more than one super-interpretation, as with the !p!$_2$ interpretation of !p!$_B$, while some valid subexpression interpretations, like the !f!$_2$ interpretation of !f!$_B$, are not used in any interpretation of their superexpression.
+Overload resolution was first seriously considered in the development of compilers for the Ada programming language, with different algorithms making various numbers of passes over the expression DAG, these passes being either top-down or bottom-up.
+Baker's algorithm~\cite{Baker82} takes a single pass from the leaves of the expression tree up, pre-computing argument candidates at each step.
+For each candidate function, Baker attempts to match argument types to parameter types in sequence, failing if any parameter cannot be matched.
+Bilson~\cite{Bilson03} similarly pre-computes argument-candidates in a single bottom-up pass in the original \CFACC{}, but then explicitly enumerates all possible argument combinations for a multi-parameter function.
+These argument combinations are matched to the parameter types of the candidate function as a unit rather than individual arguments.
+Bilson's approach is less efficient than Baker's, as the same argument may be compared to the same parameter many times, but does allow a more straightforward handling of polymorphic type-binding and tuple-typed expressions.
+Unlike Baker and Bilson, Cormack's algorithm~\cite{Cormack81} requests argument candidates that match the type of each parameter of each candidate function, in a single pass from the top-level expression down; memoization of these requests is presented as an optimization.
+As presented, this algorithm requires the parameter to have a known type, which is a poor fit for polymorphic type parameters in \CFA{}.
+Cormack's algorithm can be modified to request argument interpretations of \emph{any} type when provided an unbound parameter type, but this eliminates any pruning gains that could be provided by the algorithm.
+Ganzinger and Ripken~\cite{Ganzinger80} propose an approach (later refined by Pennello~\etal{}~\cite{Pennello80}) that uses a top-down filtering pass followed by a bottom-up filtering pass to reduce the number of candidate interpretations; they prove that a small number of such iterations is sufficient to converge to a solution for the overload resolution problem in the Ada programming language.
+Persch~\etal{}~\cite{PW:overload} developed a similar two-pass approach where the bottom-up pass is followed by the top-down pass.
+These approaches differ from Baker, Bilson, or Cormack in that they take multiple passes over the expression tree to yield a solution by applying filtering heuristics to all expression nodes.
+This approach of filtering out invalid types is unsuited to \CFA{} expression resolution, however, due to the presence of polymorphic functions and implicit conversions.
+Some other language designs solve the matching problem by forcing a bottom-up order.
+\CC{}, for instance, defines its overload-selection algorithm in terms of a partial order between function overloads given a fixed list of argument candidates, implying that the arguments must be selected before the function.
+This design choice improves worst-case expression resolution time by only propagating a single candidate for each subexpression, but type annotations must be provided for any function call that is polymorphic in its return type, and these annotations are often redundant:
+\begin{C++}
+template<typename T> T* malloc() { /* ... */ }
+int* p = malloc<int>(); $\C{// T = int must be explicitly supplied}$
+\end{C++}
+\CFA{} saves programmers from redundant annotations with its richer inference:
+\begin{cfa}
+forall(dtype T | sized(T)) T* malloc();
+int* p = malloc(); $\C{// Infers T = int from left-hand side}$
+\end{cfa}
+Baker~\cite{Baker82} left empirical comparison of different overload resolution algorithms to future work; Bilson~\cite{Bilson03} described an extension of Baker's algorithm to handle implicit conversions and polymorphism, but did not further explore the space of algorithmic approaches to handle both overloaded names and implicit conversions.
+This thesis closes that gap in the literature by performing performance comparisons of both top-down and bottom-up expression resolution algorithms, with results reported in Chapter~\ref{expr-chap}.
+\subsection{Assertion Satisfaction} \label{assn-sat-sec}
+The assertion satisfaction algorithm designed by Bilson~\cite{Bilson03} for the original \CFACC{} is the most-relevant prior work to this project.
+Before accepting any subexpression candidate, Bilson first checks that that candidate's assertions can all be resolved; this is necessary due to Bilson's addition of assertion satisfaction costs to candidate costs (discussed in Section~\ref{conv-cost-sec}).
+If this subexpression interpretation ends up not being used in the final resolution, then the (sometimes substantial) work of checking its assertions ends up wasted.
+Bilson's assertion checking function recurses on two lists, !need! and !newNeed!, the current declaration's assertion set and those implied by the assertion-satisfying declarations, respectively, as detailed in the pseudo-code below (ancillary aspects of the algorithm are omitted for clarity):
+\begin{cfa}
+List(List(Declaration)) checkAssertions(
+                List(Assertion) need, List(Assertion) newNeed, List(Declaration) have,
+                Environment env ) {
+        if ( is_empty(need) ) {
+                if ( is_empty( newNeed ) ) return { have };
+                else return checkAssertions( newNeed, {}, have, env );
+        }
+        Assertion a = head(need);
+        Type adjType = substitute( a.type, env );
+        List(Declaration) candidates = decls_matching( a.name );
+        List(List(Declaration)) alternatives = {}
+        for ( Declaration c : candidates ) {
+                Environment newEnv = env;
+                if ( unify( adjType, c.type, newEnv ) ) {
+                        append( alternatives,
+                                checkAssertions(
+                                        tail(need), append(newNeed, c.need), append(have, c), newEnv ) );
+                }
+        }
+        return alternatives;
+}
+\end{cfa}
+One shortcoming of this approach is that if an earlier assertion has multiple valid candidates, later assertions may be checked many times due to the structure of the recursion.
+Satisfying declarations for assertions are not completely independent of each other, since the unification process may produce new type bindings in the environment, and these bindings may not be compatible between independently-checked assertions.
+Nonetheless, with the environment data-structures discussed in Chapter~\ref{env-chap}, I have found it more efficient to produce a list of possibly-satisfying declarations for each assertion once, then check their respective environments for mutual compatibility when combining lists of assertions together.
+Another improvement I have made to the assertion resolution scheme in \CFACC{} is to consider all assertion-satisfying combinations at one level of recursion before attempting to recursively satisfy any !newNeed! assertions.
+Monomorphic functions are cheaper than polymorphic functions for assertion satisfaction because they are an exact match for the environment-adjusted assertion type, whereas polymorphic functions require an extra type binding.
+Thus, if there is any mutually-compatible set of assertion-satisfying declarations that does not include any polymorphic functions (and associated recursive assertions), then the optimal set of assertions does not require any recursive !newNeed! satisfaction.
+More generally, due to the \CFA{} cost-model changes I introduced in Section~\ref{conv-cost-sec}, the conversion cost of an assertion-satisfying declaration is no longer dependent on the conversion cost of its own assertions.
+As such, all sets of mutually-compatible assertion-satisfying declarations can be sorted by their summed conversion costs, and the recursive !newNeed! satisfaction pass is required only to check the feasibility of the minimal-cost sets.
+This optimization significantly reduces wasted work relative to Bilson's approach, as well as avoiding generation of deeply-recursive assertion sets, for a significant performance improvement relative to Bilson's \CFACC{}.
+Making the conversion cost of an interpretation independent of the cost of satisfying its assertions has further benefits.
+Bilson's algorithm checks assertions for all subexpression interpretations immediately, including those that are not ultimately used; I have developed a \emph{deferred} variant of assertion checking that waits until a top-level interpretation has been generated to check any assertions.
+If the assertions of the minimal-cost top-level interpretation cannot be satisfied then the next-most-minimal-cost interpretation's assertions are checked, and so forth until a minimal-cost satisfiable interpretation (or ambiguous set thereof) is found, or no top-level interpretations are found to have satisfiable assertions.
+In the common case where the code actually does compile, this saves the work of checking assertions for ultimately-rejected interpretations, though it does rule out some pruning opportunities for subinterpretations with unsatisfiable assertions or which are more expensive than a minimal-cost polymorphic function with the same return type.
+The experimental results in Chapter~\ref{expr-chap} indicate that this is a worthwhile trade-off.
+Optimizing assertion satisfaction for common idioms has also proved effective in \CFA{}; the code below is an unexceptional print statement derived from the \CFA{} test suite that nonetheless is a very difficult instance of expression resolution:
+\begin{cfa}
+sout | "one" | 1 | "two" | 2 | "three" | 3 | "four" | 4 | "five" | 5 | "six" | 6
+        | "seven" | 7 | "eight" | 8 | "nine" | 9 | "ten" | 10 | "end" | nl | nl;
+\end{cfa}
+The first thing that makes this expression so difficult is that it is 23 levels deep; Section~\ref{resn-analysis-sec} indicates that the worst-case bounds on expression resolution are exponential in expression depth.
+Secondly, the !?|?! operator is significantly overloaded in \CFA{} --- there are 74 such operators in the \CFA{} standard library, and while 9 are arithmetic operators inherited from C, the rest are polymorphic I/O operators that look similar to:
+\begin{cfa}
+forall( dtype ostype | ostream( ostype ) )
+ostype& ?|? ( ostype&, int );
+\end{cfa}
+Note that !ostream! is a trait with 25 type assertions, and that the output operators for the other arithmetic types are also valid for the !int!-type parameters due to implicit conversions.
+On this instance, deferred assertion satisfaction saves wasted work checking assertions on the wrong output operators, but does nothing about the 23 repeated checks of the 25 assertions to determine that !ofstream! (the type of !sout!) satisfies !ostream!.
+To solve this problem, I have developed a \emph{cached} variant of assertion checking.
+During the course of checking the assertions of a single top-level expression, the results are cached for each assertion checked.
+The search key for this cache is the assertion declaration with its type variables substituted according to the type environment to distinguish satisfaction of the same assertion for different types.
+This adjusted assertion declaration is then run through the \CFA{} name-mangling algorithm to produce an equivalent string-type key.
+One superficially-promising optimization, which I did not pursue, is caching assertion-satisfaction judgments among top-level expressions.
+This approach would be difficult to correctly implement in a \CFA{} compiler, due to the lack of a closed set of operations for a given type.
+New declarations related to a particular type can be introduced in any lexical scope in \CFA{}, and these added declarations may cause an assertion that was previously satisfiable to fail due to an introduced ambiguity.
+Furthermore, given the recursive nature of assertion satisfaction and the possibility of this satisfaction judgment depending on an inferred type, an added declaration may break satisfaction of an assertion with a different name and that operates on different types.
+Given these concerns, correctly invalidating a cross-expression assertion satisfaction cache for \CFA{} is a non-trivial problem, and the overhead of such an approach may possibly outweigh any benefits from such caching.
+The assertion satisfaction aspect of \CFA{} expression resolution bears some similarity to satisfiability problems from logic, and as such other languages with similar trait and assertion mechanisms make use of logic-program solvers in their compilers.
+For instance, Matsakis~\cite{Matsakis17} and the Rust team have developed a PROLOG-based engine to check satisfaction of Rust traits.
+The combination of the assertion satisfaction elements of the problem with the conversion-cost model of \CFA{} makes this logic-solver approach difficult to apply in \CFACC{}, however.
+Expressing assertion resolution as a satisfiability problem ignores the cost optimization aspect, which is necessary to decide among what are often many possible satisfying assignments of declarations to assertions.
+(MaxSAT solvers \cite{Morgado13}, which allow weights on solutions to satisfiability problems, may be a productive avenue for future investigation.)
+On the other hand, the deeply-recursive nature of the satisfiability problem makes it difficult to adapt to optimizing solver approaches such as linear programming.
+To maintain a well-defined programming language, any optimization algorithm used must provide an exact (rather than approximate) solution; this constraint also rules out a whole class of approximately-optimal generalized solvers.
+As such, I opted to continue Bilson's approach of designing a bespoke solver for \CFA{} assertion satisfaction, rather than attempting to re-express the problem in some more general formalism.
+\section{Conclusion \& Future Work} \label{resn-conclusion-sec}
+As the results in Chapter~\ref{expr-chap} show, the algorithmic approaches I have developed for \CFA{} expression resolution are sufficient to build a practically-performant \CFA{} compiler.
+This work may also be of use to other compiler construction projects, notably to members of the \CC{} community as they implement the new Concepts \cite{C++Concepts} standard, which includes type assertions similar to those used in \CFA{}, as well as the C-derived implicit conversion system already present in \CC{}.
+I have experimented with using expression resolution rather than type unification to check assertion satisfaction; this variant of the expression resolution problem should be investigated further in future work.
+This approach is more flexible than type unification, allowing for conversions to be applied to functions to satisfy assertions.
+Anecdotally, this flexibility matches user-programmer expectations better, as small type differences (\eg{} the presence or absence of a reference type, or the usual conversion from !int! to !long!) no longer break assertion satisfaction.
+Practically, the resolver prototype discussed in Chapter~\ref{expr-chap} uses this model of assertion satisfaction, with no apparent deficit in performance; the generated expressions that are resolved to satisfy the assertions are easier than the general case because they never have nested subexpressions, which eliminates much of the theoretical differences between unification and resolution.
+The main challenge to implement this approach in \CFACC{} is applying the implicit conversions generated by the resolution process in the code-generation for the thunk functions that \CFACC{} uses to pass type assertions to their requesting functions with the proper signatures.
+One \CFA{} feature that could be added to improve the ergonomics of overload selection is an \emph{ascription cast}; as discussed in Section~\ref{expr-cost-sec}, the semantics of the C cast operator are to choose the cheapest argument interpretation which is convertible to the target type, using the conversion cost as a tie-breaker.
+An ascription cast would reverse these priorities, choosing the argument interpretation with the cheapest conversion to the target type, only using interpretation cost to break ties\footnote{A possible stricter semantics would be to select the cheapest interpretation with a zero-cost conversion to the target type, reporting a compiler error otherwise.}.
+This would allow ascription casts to the desired return type to be used for overload selection:
+\begin{cfa}
+int f$\(_1\)$(int);
+int f$\(_2\)$(double);
+int g$\(_1\)$(int);
+double g$\(_2\)$(long);
+f((double)42);  $\C[4.5in]{// select f\(_2\) by argument cast}$
+(as double)g(42); $\C[4.5in]{// select g\(_2\) by return ascription cast}$
+(double)g(42); $\C[4.5in]{// select g\(_1\) NOT g\(_2\) because of parameter conversion cost}$
+\end{cfa}
+Though performance of the existing resolution algorithms is promising, some further optimizations do present themselves.
+The refined cost model discussed in Section~\ref{conv-cost-sec} is more expressive, but requires more than twice as many fields; it may be fruitful to investigate more tightly-packed in-memory representations of the cost-tuple, as well as comparison operations that require fewer instructions than a full lexicographic comparison.
+Integer or vector operations on a more-packed representation may prove effective, though dealing with the negative-valued $specialization$ field may require some effort.
+Parallelization of various phases of expression resolution may also be useful.
+The algorithmic variants I have introduced for both argument-parameter matching and assertion satisfaction are essentially divide-and-conquer algorithms, which solve subproblem instances for each argument or assertion, respectively, then check mutual compatibility of the solutions.
+While the checks for mutual compatibility are naturally more serial, there may be some benefit to parallel resolution of the subproblem instances.
+The resolver prototype built for this project and described in Chapter~\ref{expr-chap} would be a suitable vehicle for many of these further experiments, and thus a technical contribution of continuing utility.
+% Mention relevance of work to C++20 concepts

doc/theses/aaron_moss_PhD/phd/thesis.tex

-              r933f32f
+              r6a9d4b4
 \usepackage{footmisc} % for double refs to the same footnote
-\usepackage{caption} % for subfigure
-\usepackage{subcaption}
 % Hyperlinks make it very easy to navigate an electronic document.
 % In addition, this is where you should specify the thesis title
 …
 % Use the "hyperref" package
 % N.B. HYPERREF MUST BE THE LAST PACKAGE LOADED; ADD ADDITIONAL PKGS ABOVE
 %\usepackage[pdftex,pagebackref=false]{hyperref} % with basic options\
 \usepackage[breaklinks,pagebackref=false]{hyperref}
+%\usepackage[pdftex,pagebackref=false]{hyperref} % with basic options
+\usepackage[pagebackref=false]{hyperref}
 % N.B. pagebackref=true provides links back from the References to the body text. This can cause trouble for printing.
 …
 \input{resolution-heuristics}
 \input{type-environment}
-\input{experiments}
 \input{conclusion}
 …
 % \nocite{*}
-% APPENDICIES
-% -----------
-\appendix
-\input{generic-bench}
 \end{document}

doc/theses/aaron_moss_PhD/phd/type-environment.tex

-              r933f32f
+              r6a9d4b4
 One key data structure for expression resolution is the \emph{type environment}.
 As discussed in Chapter~\ref{resolution-chap}, being able to efficiently determine which type variables are bound to which concrete types or whether two type environments are compatible is a core requirement of the resolution algorithm.
+Furthermore, expression resolution involves a search through many related possible solutions, so the ability to re-use shared subsets of type-environment data and to switch between environments quickly is desirable for performance.
+In this chapter, I discuss a number of type-environment data-structure variants, including some novel variations on the union-find \cite{Galler64} data structure introduced in this thesis.
+Chapter~\ref{expr-chap} contains empirical comparisons of the performance of these data structures when integrated into the resolution algorithm.
+Furthermore, expression resolution involves a search through many related possible solutions, so being able to re-use shared subsets of type environment data and to switch between environments quickly is desirable for performance.
+In this chapter I discuss and empirically compare a number of type environment data structure variants, including some novel variations on the union-find\cite{Galler64} data structure introduced in this thesis.
 \section{Definitions} \label{env-defn-sec}
 For purposes of this chapter, a \emph{type environment} $T$ is a set of \emph{type classes} $\myset{T_1, T_2, \cdots, T_{|T|}}$.
+Each type class $T_i$ contains a set of \emph{type variables} $\myset{v_{i,1}, v_{i,2}, \cdots, v_{i,|T_i|}}$.
+Since the type classes represent an equivalence relation over the type variables the sets of variables contained in two distinct classes in the same environment must be \emph{disjoint}.
+Each individual type class $T_i$ may also be associated with a \emph{bound}, $b_i$; this bound contains the \emph{bound type} that the variables in the type class are replaced with, but also includes other information in \CFACC{}, including whether type conversions are permissible on the bound type and what sort of type variables are contained in the class (data types, function types, or variadic tuples).
+The following example demonstrates the use of a type environment for unification:
+\begin{cfa}
+forall(otype F) F f(F, F);
+forall(otype G) G g(G);
+f( g(10), g(20) );
+\end{cfa}
+Expression resolution starts from an empty type environment; from this empty environment, the calls to !g! can be independently resolved.
+These resolutions result in two new type environments, $T = \{ \myset{\mathsf{G}_1} \rightarrow$ !int!$\}$ and $T' = \{ \myset{\mathsf{G}_2} \rightarrow$ !int!$\}$; the calls to !g! have generated distinct type variables !G!$_1$ and !G!$_2$, each bound to !int! by unification with the type of its argument (!10! and !20!, both !int!).
+To complete resolution of the call to !f!, both environments must be combined; resolving the first argument to !f! produces a new type environment $T'' = \{ \myset{\mathsf{G}_1, \mathsf{F}_1} \rightarrow$ !int!$\}$: the new type variable !F!$_1$ has been introduced and unified with !G!$_1$ (the return type of !g(10)!), and consequently bound to !int!.
+To resolve the second argument to !f!, $T''$ must be checked for compatibility with $T'$; since !F!$_1$ unifies with !G!$_2$, their type classes must be merged.
+Since both !F!$_1$ and !G!$_2$ are bound to !int!, this merge succeeds, producing the final environment $T'' = \{ \myset{\mathsf{G}_1, \mathsf{F}_1, \mathsf{G}_2} \rightarrow$ !int!$\}$.
+Each type class $T_i$ contains a set of \emph{type variables} $\myset{v_{i,1}, v_{i,2}, \cdots, v_{i,|T_i|}}$; note that the sets of variables contained in two distinct classes in the same environment must be disjoint.
+Each individual type class $T_i$ may also be associated with a \emph{bound}, $b_i$; this bound contains the \emph{bound type} which the variables in the type class are replaced with, but also includes other information in \CFACC{}, including whether type conversions are permissible on the bound type and what sort of type variables are contained in the class (data types, function types, or variadic tuples).
 \begin{table}
 …
 \centering
 \begin{tabular}{r@{\hskip 0.25em}ll}
+        \hline
+        $find(T, v_{i,j})$ & $\rightarrow T_i~|~\mathsf{fail}$          & Locate class for variable             \\
+        $find(T, v_{i,j})$ & $\rightarrow T_i | \bot$           & Locate class for variable             \\
         $report(T_i)$ & $\rightarrow \{ v_{i,j} \cdots \}$      & List variables for class              \\
         $bound(T_i)$ & $\rightarrow b_i~|~\mathsf{fail}$                                & Get bound for class                   \\
         $insert(T, v_{i,1})$ &                                                          & New single-variable class             \\
+        $bound(T_i)$ & $\rightarrow b_i | \bot$                         & Get bound for class                   \\
+        $insert(v_{i,1})$ &                                                                     & New single-variable class             \\
         $add(T_i, v_{i,j})$ &                                                           & Add variable to class                 \\
         $bind(T_i, b_i)$ &                                                                      & Set or update class bound             \\
+        \hline
+        $unify(T, T_i, T_j)$ & $\rightarrow \mathsf{pass}~|~\mathsf{fail}$      & Combine two type classes              \\
+        $unify(T, T_i, T_j)$ & $\rightarrow \top | \bot$        & Combine two type classes              \\
         $split(T, T_i)$ & $\rightarrow T'$                                      & Revert the last $unify$ operation on $T_i$            \\
         $combine(T, T')$ & $\rightarrow \mathsf{pass}~|~\mathsf{fail}$          & Merge two environments                \\
+        $combine(T, T')$ & $\rightarrow \top | \bot$            & Merge two environments                \\
         $save(T)$ & $\rightarrow H$                                                     & Get handle for current state  \\
+        $backtrack(T, H)$ &                                                                     & Return to handle state                \\
+        \hline
+        $backtrack(T, H)$ &                                                                     & Return to handle state
 \end{tabular}
 \end{table}
 Type environments in \CFACC{} need to support eleven basic operations, summarized in Table~\ref{env-op-table}.
 The first six operations are straightforward queries and updates on these data structures:
 The lookup operation $find(T, v_{i,j})$ produces $T_i$, the type class in $T$ that contains variable $v_{i,j}$, or an invalid sentinel value for no such class.
+Given this basic structure, type environments in \CFACC{} need to support eleven basic operations, summarized in Table~\ref{env-op-table}.
+The first seven operations are straightforward queries and updates on these data structures:
+The lookup operation $find(T, v_{i,j})$ produces $T_i$, the type class in $T$ which contains variable $v_{i,j}$, or an invalid sentinel value for no such class.
 The other two query operations act on type classes, where $report(T_i)$ produces the set $\myset{v_{i,1}, v_{i,2}, \cdots, v_{i,|T_i|}}$ of all type variables in a class $T_i$ and $bound(T_i)$ produces the bound $b_i$ of that class, or a sentinel indicating no bound is set.
 The update operation $insert(T, v_{i,1})$ creates a new type class $T_i$ in $T$ that contains only the variable $v_{i,1}$ and no bound; due to the disjointness property, $v_{i,1}$ must not belong to any other type class in $T$.
+The update operation $insert(T, v_{i,1})$ creates a new type class $T_i$ in $T$ that contains only the variable $v_{i,1}$ and no bound; due to the disjointness property $v_{i,1}$ cannot belong to any other type class in $T$.
 The $add(T_i, v_{i,j})$ operation adds a new type variable $v_{i,j}$ to class $T_i$; again, $v_{i,j}$ cannot exist elsewhere in $T$.
 $bind(T_i, b_i)$ mutates the bound for a type class, setting or updating the current bound.
 The $unify$ operation is the fundamental non-trivial operation a type-environment data-structure must support.
+The $unify$ operation is the fundamental non-trivial operation a type environment data structure must support.
 $unify(T, T_i, T_j)$ merges a type class $T_j$ into another $T_i$, producing a failure result and leaving $T$ in an invalid state if this merge fails.
 It is always possible to unify the type variables of both classes by simply taking the union of both sets; given the disjointness property, no checks for set containment are required, and the variable sets can simply be concatenated if supported by the underlying data structure.
 $unify$ depends on an internal $unifyBound$ operation, which may fail.
 In \CFACC{}, $unifyBound(b_i, b_j) \rightarrow b'_i~|~\mathsf{fail}$ checks that the type classes contain the same sort of variable, takes the tighter of the two conversion permissions, and checks if the bound types can be unified.
+$unify$ depends on an internal $unifyBound$ operation which may fail.
+In \CFACC{}, $unifyBound(b_i, b_j) \rightarrow b'_i|\bot$ checks that the type classes contain the same sort of variable, takes the tighter of the two conversion permissions, and checks if the bound types can be unified.
 If the bound types cannot be unified (\eg{} !struct A! with !int*!), then $unifyBound$ fails, while other combinations of bound types may result in recursive calls.
 For instance, unifying !R*! with !S*! for type variables !R! and !S! results in a call to $unify(T, find($!R!$), find($!S!$))$, while unifying !R*! with !int*! results in a call to $unifyBound$ on !int! and the bound type of the class containing !R!.
+For instance, unifying !R*! with !S*! for type variables !R! and !S! will result in a call to $unify(T, find($!R!$), find($!S!$))$, while unifying !R*! with !int*! will result in a call to $unifyBound$ on !int! and the bound type of the class containing !R!.
 As such, a call to $unify(T, T_i, T_j)$ may touch every type class in $T$, not just $T_i$ and $T_j$, collapsing the entirety of $T$ into a single type class in extreme cases.
 For more information on \CFA{} unification, see \cite{Bilson03}.
 The inverse of $unify$ is $split(T, T_i)$, which produces a new environment $T'$ that is the same as $T$ except that $T_i$ has been replaced by two classes corresponding to the arguments to the previous call to $unify$ on $T_i$.
 If there is no prior call to $unify$ on $T_i$ (\ie{} $T_i$ is a single-element class) $T_i$ is absent in $T'$.
 Given the nature of the expression resolution problem as a backtracking search, caching and concurrency are both useful tools to decrease runtime.
+The inverse of $unify$ is $split(T, T_i)$, which produces a new environment $T'$ which is the same as $T$ except that $T_i$ has been replaced by two classes corresponding to the arguments to the previous call to $unify$ on $T_i$.
+If there has been no call to $unify$ on $T_i$ (\ie{} $T_i$ is a single-element class) $T_i$ is absent in $T'$.
+Given the nature of the expression resolution problem as backtracking search, caching and concurrency are both useful tools to decrease runtime.
 However, both of these approaches may produce multiple distinct descendants of the same initial type environment, which have possibly been mutated in incompatible ways.
 As such, to effectively employ either caching or concurrency, the type environment data structure must support an efficient method to check if two type environments are compatible and merge them if so.
 $combine(T,T')$ attempts to merge an environment $T'$ into another environment $T$, producing $\mathsf{pass}$ if successful or leaving $T$ in an invalid state and producing $\mathsf{fail}$ otherwise.
 The invalid state of $T$ on failure is not important, given that a combination failure results in the resolution algorithm backtracking to a different environment.
+As such, to effectively employ either concurrency or caching, the type environment data structure must support an efficient method to check if two type environments are compatible and merge them if so.
+$combine(T,T')$ attempts to merge an environment $T'$ into another environment $T$, producing $\top$ if successful or leaving $T$ in an invalid state and producing $\bot$ otherwise.
+The invalid state of $T$ on failure is not important, given that a combination failure will result in the resolution algorithm backtracking to a different environment.
 $combine$ proceeds by calls to $insert$, $add$, and $unify$ as needed, and can be roughly thought of as calling $unify$ on every pair of classes in $T$ that have variables $v'_{i,j}$ and $v'_{i,k}$ in the same class $T'_i$ in $T'$.
 Like $unify$, $combine$ can always find a mutually-consistent partition of type variables into classes (in the extreme case, all type variables from $T$ and $T'$ in a single type class), but may fail due to inconsistent bounds on merged type classes.
 …
 The set of mutations to a type environment across the execution of the resolution algorithm produce an implicit tree of related environments, and the backtracking search typically focuses only on one leaf of the tree at once, or at most a small number of closely-related nodes as arguments to $combine$.
 As such, the ability to save and restore particular type environment states is useful, and supported by the $save(T) \rightarrow H$ and $backtrack(T, H)$ operations, which produce a handle for the current environment state and mutate an environment back to a previous state, respectively.
 These operations can be naively implemented by a deep copy of $T$ into $H$ and vice versa, but have more efficient implementations in persistency-aware data structures such as the persistent union-find introduced in Section~\ref{env-persistent-union-find}.
 \section{Approaches} \label{env-approaches-sec}
 \subsection{Na\"{\i}ve} \label{naive-env-sec}
 The type environment data structure used in Bilson's~\cite{Bilson03} original implementation of \CFACC{} is a simple translation of the definitions in Section~\ref{env-defn-sec} to \CC{} code; a !TypeEnvironment! contains a list of !EqvClass! type equivalence classes, each of which contains the type bound information and a tree-based sorted set of type variables.
+These operations can be naively implemented by a deep copy of $T$ into $H$ and vice versa, but have more efficient implementations in persistency-aware data structures.
+\section{Approaches}
+\subsection{Na\"{\i}ve}
+The type environment data structure used in Bilson's\cite{Bilson03} original implementation of \CFACC{} is a straightforward translation of the definitions in Section~\ref{env-defn-sec} to \CC{} code; a !TypeEnvironment! contains a list of !EqvClass! type equivalence classes, each of which contains the type bound information and a tree-based sorted set of type variables.
 This approach has the benefit of being easy to understand and not imposing life-cycle or inheritance constraints on its use, but, as can be seen in Table~\ref{env-bounds-table}, does not support many of the desired operations with any particular efficiency.
 Some variations on this structure may improve performance somewhat; for instance, replacing the !EqvClass! variable storage with a hash-based set reduces search and update times from $O(\log n)$ to amortized $O(1)$, while adding an index for the type variables in the entire environment removes the need to check each type class individually to maintain the disjointness property.
+Some variations on this structure may improve performance somewhat; for instance, replacing the !EqvClass! variable storage with a hash-based set would reduce search and update times from $O(\log n)$ to amortized $O(1)$, while adding an index for the type variables in the entire environment would remove the need to check each type class individually to maintain the disjointness property.
 These improvements do not change the fundamental issues with this data structure, however.
 \subsection{Incremental Inheritance} \label{inc-env-sec}
 One more invasive modification to this data structure that I investigated is to support swifter combinations of closely-related environments in the backtracking tree by storing a reference to a \emph{parent} environment within each environment, and having that environment only store type classes that have been modified with respect to the parent.
+\subsection{Incremental Inheritance}
+One more invasive modification to this data structure which I investigated is to support swifter combinations of closely-related environments in the backtracking tree by storing a reference to a \emph{parent} environment within each environment, and having that environment only store type classes which have been modified with respect to the parent.
 This approach provides constant-time copying of environments, as a new environment simply consists of an empty list of type classes and a reference to its (logically identical) parent; since many type environments are no different than their parent, this speeds backtracking in this common case.
 Since all mutations made to a child environment are by definition compatible with the parent environment, two descendants of a common ancestor environment can be combined by iteratively combining the changes made in one environment, then that environment's parent, until the common ancestor is reached, again re-using storage and reducing computation in many cases.
 For this environment, I also employed a lazily-generated index of type variables to their containing class, which could be in either the current environment or an ancestor.
 Any mutation of a type class in an ancestor environment causes that class to be copied into the current environment before mutation, as well as added to the index, ensuring all local changes to the type environment are listed in its index.
+Since all mutations made to a child environment are by definition compatible with the parent environment, two descendants of a common ancestor environment can be combined by iteratively combining the changes made in one environment then that environment's parent until the common ancestor is reached, again re-using storage and reducing computation in many cases.
+For this environment I also employed a lazily-generated index of type variables to their containing class, which could be in either the current environment or an ancestor.
+Any mutation of a type class in an ancestor environment would cause that class to be copied into the current environment before mutation, as well as added to the index, ensuring that all local changes to the type environment are listed in its index.
 However, not adding type variables to the index until lookup or mutation preserves the constant-time environment copy operation in the common case in which the copy is not mutated from its parent during its life-cycle.
 This approach imposes some performance penalty on $combine$ if related environments are not properly linked together, as the entire environment needs to be combined rather than just the difference, but is correct as long as the ``null parent'' base-case is properly handled.
+This approach imposes some performance penalty on $combine$ if related environments are not properly linked together, as the entire environment needs to be combined rather than just the diff, but is correct as long as the ``null parent'' base case is properly handled.
 The life-cycle issues are somewhat more complex, as many environments may descend from a common parent, and all of these need their parent to stay alive for purposes of lookup.
 These issues can be solved by ``flattening'' parent nodes into their children before the parent's scope ends, but given the tree structure of the inheritance graph it is more straightforward to store the parent nodes in reference-counted or otherwise automatically garbage-collected heap storage.
+These issues can be solved by ``flattening'' parent nodes into their children before the parents leave scope, but given the tree structure of the inheritance graph it is more straightforward to store the parent nodes in reference-counted or otherwise automatically garbage-collected heap storage.
 \subsection{Union-Find} \label{env-union-find-approach}
 Given the nature of the classes of type variables as disjoint sets, another natural approach to implementing a type environment is the union-find disjoint-set data-structure~\cite{Galler64}.
+Given the nature of the classes of type variables as disjoint sets, another natural approach to implementing a type environment is the union-find disjoint set data structure\cite{Galler64}.
 Union-find efficiently implements two operations over a partition of a collection of elements into disjoint sets; $find(x)$ locates the \emph{representative} of $x$, the element which canonically names its set, while $union(r, s)$ merges two sets represented by $r$ and $s$, respectively.
 The union-find data structure is based on providing each element with a reference to its parent element, such that the root of a tree of elements is the representative of the set of elements contained in the tree.
 $find$ is then implemented by a search up to the parent, generally combined with a \emph{path compression} step that links nodes more directly to their ancestors to speed up subsequent searches.
 $union$ involves making the representative of one set a child of the representative of the other, generally employing a rank- or size-based heuristic to ensure that the tree remains somewhat balanced.
 If both path compression and a balancing heuristic are employed, both $union$ and $find$ run in amortized $O(\alpha(n))$ worst-case time; this inverse Ackermann bound is a small constant for all practical values of $n$ \cite{Tarjan75}.
+If both path compression and a balancing heuristic are employed, both $union$ and $find$ run in amortized $O(\alpha(n))$ worst-case time; this bound by the inverse Ackermann function is a small constant for all practical values of $n$.
 The union-find $find$ and $union$ operations have obvious applicability to the $find$ and $unify$ type environment operations in Table~\ref{env-op-table}, but the union-find data structure must be augmented to fully implement the type environment operations.
 In particular, the type-class bound cannot be easily included in the union-find data structure, as the requirement to make it the class representative breaks the balancing properties of $union$, and requires too-close integration of the type environment $unifyBound$ internal operation.
 This issue can be solved by including a side map from class representatives to the type-class bound.
 If placeholder values are inserted in this map for type classes without bounds then this also has the useful property that the key set of the map provides an easily obtainable list of all the class representatives, a list which cannot be derived from the union-find data structure without a linear search for class representatives through all elements.
+In particular, the type class bound cannot be easily included in the union-find data structure, as the requirement to make it the class representative breaks the balancing properties of $union$, and requires too-close integration of the type environment $unifyBound$ internal operation.
+This issue can be solved by including a side map from class representatives to the type class bound.
+If placeholder values are inserted in this map for type classes without bounds than this also has the useful property that the key set of the map provides an easily obtainable list of all the class representatives, a list which cannot be derived from the union-find data structure without a linear search for class representatives through all elements.
 \subsection{Union-Find with Classes} \label{env-union-find-classes-approach}
 …
 Another type environment operation not supported directly by the union-find data structure is $report$, which lists the type variables in a given class, and similarly $split$, which reverts a $unify$ operation.
 Since the union-find data structure stores only links from children to parents and not vice-versa, there is no way to reconstruct a class from one of its elements without a linear search over the entire data structure, with $find$ called on each element to check its membership in the class.
+The situation is even worse for the $split$ operation, which requires extra information to maintain the order that each child is added to its parent node.
+Unfortunately, the literature \cite{Tarjan84,Galil91,Patwary10} on union-find does not present a way to keep references to children without breaking the asymptotic time bounds of the algorithm; I have discovered a method to do so, which, despite its simplicity, seems to be novel.
+The situation is even worse for the $split$ operation, which would require extra information to maintain the order that each child was added to its parent node.
+Unfortunately, the literature\cite{Tarjan84,Galil91,Patwary10} on union-find does not present a way to keep references to children without breaking the asymptotic time bounds of the algorithm; I have discovered a method to do so which, despite its simplicity, seems to be novel.
+\TODO{port figure from slideshow}
 The core idea of this ``union-find with classes'' data structure and algorithm is to keep the members of each class stored in a circularly-linked list.
 …
 In my version, the list data structure does not affect the layout of the union-find tree, maintaining the same asymptotic bounds as union-find.
 In more detail, each element is given a !next! pointer to another element in the same class; this !next! pointer initially points to the element itself.
 When two classes are unified, the !next! pointers of the representatives of those classes are swapped, splicing the two circularly-linked lists together as illustrated in Figure~\ref{union-find-classes-fig}.
+When two classes are unified, the !next! pointers of the representatives of those classes are swapped, splicing the two circularly-linked lists together.
 Importantly, though this approach requires an extra pointer per element, it does maintain the linear space bound of union-find, and because it only requires updating the two root nodes in $union$ it does not asymptotically increase runtime either.
 The basic approach is compatible with all path-compression techniques, and allows the members of any class to be retrieved in time linear in the size of the class simply by following the !next! pointers from any element.
-\begin{figure}
-        \centering
-        \includegraphics{figures/union-find-with-classes}
-        \caption[Union operation for union-find with classes.]{Union operation for union-find with classes. Solid lines indicate parent pointers, dashed lines are \lstinline{next} pointers.}
-        \label{union-find-classes-fig}
-\end{figure}
 If the path-compression optimization is abandoned, union-find with classes also encodes a reversible history of all the $union$ operations applied to a given class.
 …
 \begin{theorem} \label{env-reverse-thm}
 The !next! pointer of a class representative in the union-find with classes algorithm, without path compression, points to a leaf from the most-recently-added subtree.
+The !next! pointer of a class representative in the union-find with classes algorithm without path compression points to a leaf from the most-recently-added subtree.
 \end{theorem}
 …
         By induction on the height of the tree. \\
         \emph{Base case:} A height 1 tree by definition includes only a single item. In such a case, the representative's !next! pointer points to itself by construction, and the representative is the most-recently-added (and only) leaf in the tree. \\
         \emph{Inductive case:} By construction, a tree $T$ of height greater than 1 has children of the root (representative) node that were representative nodes of classes merged by $union$. By definition, the most-recently-added subtree $T'$ has a smaller height than $T$, thus by the inductive hypothesis before the most-recent $union$ operation, the !next! pointer of the root of $T'$ pointed to one of the leaf nodes of $T'$; by construction the !next! pointer of the root of $T$ points to this leaf after the $union$ operation.
+        \emph{Inductive case:} By construction, a tree $T$ of height greater than 1 has children of the root (representative) node that were representative nodes of classes merged by $union$. By definition, the most-recently-added subtree $T'$ has a smaller height than $T$, thus by the inductive hypothesis before the most-recent $union$ operation the !next! pointer of the root of $T'$ pointed to one of the leaf nodes of $T'$; by construction the !next! pointer of the root of $T$ points to this leaf after the $union$ operation.
 \end{proof}
 …
 \subsection{Persistent Union-Find}
+\label{env-persistent-union-find}
+Given the backtracking nature of the resolution algorithm discussed in Section~\ref{env-defn-sec}, the abilities to quickly switch between related versions of a type environment and to de-duplicate shared data among environments are both assets to performance.
+Given the backtracking nature of the resolution algorithm discussed in Section~\ref{env-defn-sec}, the abilities to quickly switch between related versions of a type environment and to de-duplicate shared data between environments are both assets to performance.
 Conchon and Filli\^{a}tre~\cite{Conchon07} present a persistent union-find data structure based on the persistent array of Baker~\cite{Baker78,Baker91}.
+In Baker's persistent array, an \emph{array reference} contains either a pointer to the array or a pointer to an \emph{edit node}; these edit nodes contain an array index, the value in that index, and another array reference pointing either to the array or a different edit node.
+By construction, these array references always point to a node more like the actual array, forming a tree of edits rooted at the actual array.
+Reads from the actual array at the root can be performed in constant time, as with a non-persistent array.
+\TODO{port figure from slideshow}
+In Baker's persistent array, an array reference contains either a pointer to the array or a pointer to an \emph{edit node}; these edit nodes contain an array index, the value in that index, and another array reference pointing either to the array or a different edit node.
+In this manner, a tree of edits is formed, rooted at the actual array.
+Read from the actual array at the root can be performed in constant time, as with a non-persistent array.
 The persistent array can be mutated in constant time by directly modifying the underlying array, then replacing its array reference with an edit node containing the mutated index, the previous value at that index, and a reference to the mutated array. If the current array reference is not the root, mutation consists simply of constructing a new edit node encoding the change and referring to the current array reference.
+The mutation algorithm at the root is a special case of the key operation on persistent arrays, $reroot$.
+The mutation algorithm at the root is in some sense a special case of the key operation on persistent arrays, $reroot$.
 A rerooting operation takes any array reference and makes it the root node of the array.
 This operation is accomplished by tracing the path from some edit node to actual array at the root node, recursively applying the edits to the underlying array and replacing each edit node's successor with the inverse edit.
+This is accomplished by tracing the path from some edit node to the root node of the array (always the underlying array), recursively applying the edits to the underlying array and replacing each edit node's successor with the inverse edit.
 In this way, any previous state of the persistent array can be restored in time proportional to the number of edits to the current state of the array.
 While $reroot$ does maintain the same value mapping in every version of the persistent array, the internal mutations it performs break thread-safety, and thus it must be used behind a lock in a concurrent context.
+While $reroot$ does maintain the same value mapping in every version of the persistent array, the internal mutations it performs means that it is not thread-safe, and must be used behind a lock in a concurrent context.
 Also, the root node with the actual array may in principle be anywhere in the tree, and does not provide information to report its leaf nodes, so some form of automatic garbage collection is generally required for the data structure.
 Since the graph of edit nodes is tree-structured, reference counting approaches suffice for garbage collection; Conchon and Filli\^{a}tre~\cite{Conchon07} also observe that if the only $reroot$ operations are for backtracking then the tail of inverse edit nodes may be elided, suggesting the possibility of stack-based memory management.
 While Conchon and Filli\^{a}tre~\cite{Conchon07} implement their persistent union-find data structure over a universe of integer elements in the fixed range $[1,N]$, the type environment problem needs more flexibility.
 In particular, an arbitrary number of type variables may be added to the environment.
 As such, a persistent hash table is a more suitable structure than a persistent array, providing the same expected asymptotic time bounds, while allowing a dynamic number of elements.
 Besides replacing the underlying array with a hash table, the other major change in this approach is to replace the two types of array references, !Array! and !Edit!, with four node types, !Table!,  !Edit!, !Add!, and !Remove!, where !Add! adds a new key-value pair, !Remove! removes a key-value pair, and !Edit! mutates an existing key-value pair.
 In this variant of \CFACC{}, this persistent hash-table is used as the side map discussed in Section~\ref{env-union-find-approach} for class bounds.
+In particular, an arbitrary number of type variables must be added to the environment.
+As such, a persistent hash table is a more suitable structure than a persistent array, providing the same expected asymptotic time bounds while allowing a dynamic number of elements.
+Besides replacing the underlying array with a hash table, the other major change in this approach is to replace the two types of array references, !Array! and !Edit!, with four node types, !Table!,  !Edit!, !Add!, and !Remove!, where !Add! adds a new key-value pair, !Remove! removes a key, and !Edit! mutates an existing key-value pair.
+In this variant of \CFACC{}, this persistent hash table is used as the side map discussed in Section~\ref{env-union-find-approach} for class bounds.
 The actual union-find data structure is slightly modified from this approach, with a !Base! node containing the root union-find data structure, !Add! nodes adding new elements, !AddTo! nodes defining the union of two type classes, and !Remove! and !RemoveFrom! nodes as inverses of the previous two elements, for purposes of maintaining the edit list.
+Figure~\ref{persistent-union-find-fig} demonstrates the structure of a simple example.
+Making !AddTo! and !RemoveFrom! single nodes provides semantic information missing from the raw array updates in Conchon and Filli\^{a}tre's data structure.
+!RemoveFrom! is implemented using the ``leaf of last union'' approach discussed in Section~\ref{env-union-find-classes-approach}; this does, however, preclude the use of path-compression algorithms in this persistent union-find data structure.
+\begin{figure}
+        \centering
+        \includegraphics{figures/persistent-union-find}
+        \caption[Persistent union-find data structure.]{Persistent union-find data structure. Shows the edit nodes to reverse back to an empty structure.}
+        \label{persistent-union-find-fig}
+\end{figure}
+This added semantic information on $union$ operations in the persistent union-find edit tree exposes a new option for combining type environments.
+Making !AddTo! and !RemoveFrom! single nodes shortens the edit path for improved performance, while also providing semantic information missing from the raw array updates in Conchon and Filli\^{a}tre's data structure.
+The single-node approach, does, however, break under most path-compression algorithms; !RemoveFrom! can be applied to the underlying data structure using the ``leaf of last union'' approach discussed in in Section~\ref{env-union-find-classes-approach}; this was judged an acceptable trade-off for the added semantic information and shortened paths.
+Maintaining explicit information on $union$ operations in the persistent union-find edit tree in the form of !AddTo! and !RemoveFrom! nodes exposes a new option for combining type environments.
 If the type environments are part of the same edit tree, one environment $T'$ can be combined with another $T$ by only testing the edits on the path from $T'$ to $T$ in both the persistent union-find data structure describing the classes and the persistent hash table containing the class bounds.
+This approach is generally more efficient than testing the compatibility of all type classes in $T'$, as only those that are actually different than those in $T$ must be considered.
+However, the improved performance comes at the cost of some flexibility, as the edit-tree link must be maintained between any two environments to be combined under this algorithm.
+This is generally more efficient than testing the compatibility of all type classes in $T'$, as only those that are actually different than those in $T$ must be considered.
 The procedure for $combine(T, T')$ based on edit paths is as follows:
 The shared edit trees for classes and bindings are rerooted at $T$, and the path from $T'$ to $T$ is followed to create a list of actual edits.
 By tracking the state of each element, redundant changes such as an !Edit! followed by an !Edit! can be reduced to their form in $T'$ by dropping the later (more like $T$) !Edit! for the same key; !Add! and !Remove! cancel similarly.
+This procedure is repeated for both the class edit-tree and the binding edit-tree.
+When the list of net changes to the environment is produced, the additive changes are applied to $T$.
+For example, if a type class exists in $T'$ but not $T$, the corresponding !Add! edit is applied to $T$, but in the reverse situation the !Remove! edit is not applied to $T$, as the intention is to produce a new environment representing the union of the two sets of type classes; similarly, !AddTo! edits are applied to unify type-classes in $T$ that are united in $T'$, but !RemoveFrom! edits that split type classes are not.
+A new environment, $T''$, can always be constructed with a consistent partitioning of type variables; in the extreme case, all variables from both $T$ and $T'$ are united in a single type class in $T''$.
+$combine$ can fail to unify the bound types; if any class in $T'$ has a class bound that does not unify with the merged class in $T''$, then $combine$ fails.
+\section{Analysis} \label{env-analysis-sec}
+In this section, I present asymptotic analyses of the various approaches to the type environment data structure discussed in the previous section.
+My results are summarized in Table~\ref{env-bounds-table}; in all cases, $n$ is the number of type classes, $m$ is the maximum size of a type class, and $p$ the number of edits between two environments or one environment and the empty environment.
+$u(n)$ captures the recursive cost of class unification, which is kept separate so that the $O(n)$ number of recursive class unifications can be distinguished from the direct cost of each recursive step.
+This procedure is repeated for both the class edit tree and the binding edit tree.
+When the list of net changes to the environment has been produced, the additive changes are applied to $T$.
+For example, if a type class exists in $T'$ but not $T$, the corresponding !Add! edit will be applied to $T$, but in the reverse situation the !Remove! edit will not be applied to $T$, as the intention is to produce a new environment representing the union of the two sets of type classes; similarly, !AddTo! edits are applied to unify type-classes in $T$ that are united in $T'$, but !RemoveFrom! edits that split type classes are not.
+The new environment, $T''$ can always be constructed with a consistent partitioning of type variables; in the extreme case, all variables from both $T$ and $T'$ will be united in a single type class in $T''$.
+Where $combine$ can fail is in unifying the bound types; if any class in $T'$ has a class bound which does not unify with the merged class in $T''$ than $combine$ fails.
+\section{Analysis}
+In this section I present asymptotic analyses of the various approaches to a type environment data structure discussed in the previous section.
 \begin{table}
 …
 \begin{tabular}{rllll}
         \hline
                                 & \textbf{Na\"{\i}ve} & \textbf{Incremental} & \textbf{Union-Find} & \textbf{Persistent U-F} \\
+                                & \textbf{Na\"{\i}ve}   & \textbf{Incremental}  & \textbf{Union-Find}           & \textbf{U-F with Classes}             \\
         \hline
+        $find$          & $O(n)$                        & $O(p)$                        & $O(\alpha(m))$        & $O(\log m)$           \\
+        $report$        & $O(m)$                        & $O(m)$                        & $O(nm\alpha(m))$      & $O(m)$                        \\
+        $bound$         & $O(1)$                        & $O(1)$                        & $O(1)$                        & $O(1)$                        \\
+        $insert$        & $O(1)$                        & $O(1)$                        & $O(1)$                        & $O(1)$                        \\
+        $add$           & $O(1)$                        & $O(m)$                        & $O(1)$                        & $O(1)$                        \\
+        $bind$          & $O(1)$                        & $O(1)$                        & $O(1)$                        & $O(1)$                        \\
+        $unify$         & $O(m + u(n))$         & $O(m + u(n))$         & $O(1 + u(n))$         & $O(1 + u(n))$         \\
+        $split$         & ---                           & ---                           & ---                           & $O(\log m)$           \\
+        $combine$       & $O(n^2m $                     & $O(p^2m $                     & $O(nm\alpha(m) $      & $O(p \log m $         \\
+                                & $~~~+ nu(n))$         & $~~~+ pu(n))$         & $~~~+ nu(n))$         & $~~~+ pu(n))$         \\
+        $save$          & $O(nm)$                       & $O(1)$                        & $O(nm)$                       & $O(1)$                        \\
+        $backtrack$     & $O(nm)$                       & $O(pm)$                       & $O(nm)$                       & $O(p)$                        \\
+        $find$          & $O(n)$                                & $O(p)$                                & $O(\alpha(m))$                        & $O(\log m)$                                   \\
+        $report$        & $O(m)$                                & $O(m)$                                & $O(n \log m)$                         & $O(m)$                                                \\
+        $bound$         & $O(1)$                                & $O(1)$                                & $O(1)$                                        & $O(1)$                                                \\
+        $insert$        & $O(1)$                                & $O(1)$                                & $O(1)$                                        & $O(1)$                                                \\
+        $add$           & $O(1)$                                & $O(1)$                                & $O(1)$                                        & $O(1)$                                                \\
+        $bind$          & $O(1)$                                & $O(1)$                                & $O(1)$                                        & $O(1)$                                                \\
+        $unify$         & $O(m + u(n))$                 & $O(m + u(n))$                 & $O(\log m + u(n))$            & $O(\log m + u(n))$                    \\
+        $split$         & ---                                   & ---                                   & ---                                           & $O(\log m)$                                   \\
+        $combine$       & $O(nm \cdot u(n))$    & $O(pm \cdot u(n))$    & $O(n \log m \cdot u(n))$      & $O(p \log m \cdot u(n))$              \\
+        $save$          & $O(nm)$                               & $O(1)$                                & $O(nm)$                                       & $O(1)$                                                \\
+        $backtrack$     & $O(nm)$                               & $O(pm)$                               & $O(nm)$                                       & $O(p)$                                                \\
         \hline
 \end{tabular}
 \end{table}
+\subsection{Na\"{\i}ve and Incremental}
+\label{naive-incremental-analysis}
+The na\"{\i}ve type environment data structure does not have an environment-wide index for type variables, but does have an index for each type class, assumed to be hash-based here.
+As a result, every class's index must be consulted for a $find$ operation, at an overall cost of $O(n)$.
+The incremental variant builds an overall hash-based index as it is queried, but may need to recursively check its parent environments if its local index does not contain a type variable, and may have as many parents as times it has been modified, for cost $O(p)$.
+It should be noted that subsequent queries for the same variable execute in constant time.
+Since both na\"{\i}ve and incremental variants store complete type classes, the cost of a $report$ operation is simply the time needed to output the contained variables, $O(m)$.
+Since the type classes store their bounds, $bound$ and $bind$ are both $O(1)$ given a type class.
+Once a $find$ operation has already been performed to verify that a type variable does not exist in the environment, the data structures for both these variants support adding new type classes (the $insert$ operation) in $O(1)$.
+Adding a variable to a type class (the $add$ operation) can be done in $O(1)$ for the na\"{\i}ve implementation, but the incremental implementation may need to copy the edited type class from a parent at cost $O(m)$.
+The linear storage of type classes in both variants also leads to $O(m)$ time for the variable-merging step in $unify$, plus the usual $u(n)$ recursion term for $unifyBound$.
+The na\"{\i}ve $combine$ operation must traverse each of the classes of one environment, merging in any class of the other environment that shares a type variable.
+Since there are at most $n$ classes to unify, the unification cost is $O(nm + nu(n))$, while traversal and $find$ costs to locate classes to merge total $O(n^2m)$, for an overall cost of $O(n^2m + nu(n))$.
+The incremental $combine$ operation works similarly, but only needs to consider classes modified in either environment with respect to the common ancestor of both environments, allowing the $n$ cost terms to be substituted for $p$, for an overall cost of $O(p^2m + pu(n))$.
+Neither variant supports the $split$ operation to undo a $unify$.
+The na\"{\i}ve environment does nothing to support $save$ and $backtrack$, so these operations must be implemented by making a deep copy of the environment on $save$, then a destructive overwrite on $backtrack$, each at a cost of $O(nm)$.
+The incremental environment supports $O(1)$ $save$ by simply setting aside a reference to the current environment, then proceeding with a new, empty environment with the former environment as a parent.
+$backtrack$ to a parent environment may involve destroying all the intermediate environments if this backtrack removes the last reference to the backtracked-from environment; this cost is $O(pm)$.
+\subsection{Union-Find}
+The union-find data structure is designed to support $find$ efficiently, and thus for any variant, the cost is simply the distance up the tree to the representative element.
+For basic union-find, this is amortized to the inverse Ackermann function, $O(\alpha(m))$, essentially a small constant, though the loss of path compression in persistent union-find raises this cost to $O(\log m)$.
+Basic union-find is not designed to support the $report$ operation, however, so it must be simulated by checking the representative of every type variable, at cost $O(nm\alpha(m))$.
+Persistent union-find, on the other hand, uses the ``with classes'' extension to union-find described in Section~\ref{env-union-find-classes-approach} to run $report$ in $O(m)$ time.
+All union-find environment variants described here use a secondary hash table to map from class representatives to bindings, and as such can perform $bound$ and $bind$ in $O(1)$, given the representative.
+$insert$ is also a $O(1)$ operation for both basic and persistent union-find.
+Since $add$ simply involves attaching a new child to the class root, it is also a $O(1)$ operation for all union-find environment variants.
+Union-find is also designed to support $unify$ in constant time, and as such, given class representatives, the variable-merging cost of $unify$ for both variants is $O(1)$ to make one representative the child of the other, plus the $O(u(n))$ term for $unifyBound$.
+Basic union-find does not support $split$, but persistent union-find can accomplish it using the mechanism described in Section~\ref{env-union-find-classes-approach} in $O(\log m)$, the cost of traversing up to the root of a class from a leaf without path compression.
+$combine$ on the basic union-find data structure works similarly to the data structures discussed above in Section~\ref{naive-incremental-analysis}, with a $O(nu(n))$ term for the $O(n)$ underlying $unify$ operations, and a $O(n\alpha(m))$ term to find the classes which need unification by checking the class representatives of each corresponding type variable in both environments for equality.
+Persistent union-find uses a different approach for $combine$, discussed in Section~\ref{env-persistent-union-find}.
+Discounting recursive $unify$ operations included in the $u(n)$ $unifyBound$ term, there may be at most $O(p)$ $unify$ operations performed, at cost $O(pu(n))$.
+Each of the $O(p)$ steps on the edit path can be processed in the $O(\log m)$ time it takes to find the current representative of the modified type class, for a total runtime of $O(p \log m + pu(n))$.
+In terms of backtracking operations, the basic union-find data structure only supports deep copies, for $O(nm)$ cost for both $save$ and $backtrack$.
+Persistent union-find, as the name suggests, is more optimized, with $O(1)$ cost to $save$ a backtrack-capable reference to the current environment state, and $O(p)$ cost to revert to that state (possibly destroying no-longer-used edit nodes along the path).
+\section{Conclusion \& Future Work}
+This chapter presents the type environment abstract data type, some type-environment data-structures optimized for workloads encountered in the expression resolution problem, and asymptotic analysis of each data structure.
+Chapter~\ref{expr-chap} provides experimental performance results for a representative set of these approaches.
+One contribution of this thesis is the union-find with classes data structure for efficient retrieval of union-find class members, along with a related algorithm for reversing the history of $union$ operations in this data structure.
+This reversible history contributes to the second novel contribution of this chapter, a type environment data structure based off the persistent union-find data structure of Conchon and Filli\^{a}tre~\cite{Conchon07}.
+This persistent union-find environment uses the $split$ operation introduced in union-find with classes and the edit history of the persistent data structure to support an environment-combining algorithm that only considers the edits between the environments to be merged.
+This persistent union-find data structure is efficient, but not thread-safe; as suggested in Section~\ref{resn-conclusion-sec}, it may be valuable to parallelize the \CFA{} expression resolver.
+However, allowing multiple threads concurrent access to the persistent data structure is likely to result in ``reroot thrashing'', as different threads reroot the data structure to their own versions of interest.
+This contention could be mitigated by partitioning the data structure into separate subtrees for each thread, with each subtree having its own root node, and the boundaries among them implemented with a lock-equipped !ThreadBoundary! edit node.
+Alternatively, the concurrent hash trie of Prokopec \etal{} \cite{Prokopec11,Prokopec12} may be a useful hash-table replacement.
+% Future work: design multi-threaded version of C&F persistent map --- core idea is some sort of thread-boundary edit node

doc/user/user.tex

-              r933f32f
+              r6a9d4b4
 %% Created On       : Wed Apr  6 14:53:29 2016
 %% Last Modified By : Peter A. Buhr
 %% Last Modified On : Sun May  5 18:24:50 2019
 %% Update Count     : 3489
+%% Last Modified On : Tue Dec 11 23:19:26 2018
+%% Update Count     : 3400
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 …
 \end{center}
 While the \CFA I/O looks similar to the \Index*[C++]{\CC{}} output style, there are important differences, such as automatic spacing between variables as in \Index*{Python} (see~\VRef{s:IOLibrary}).
 \subsection{Background}
 …
 which conditionally includes the correct header file, if the program is compiled using \Indexc{gcc} or \Indexc{cfa}.
-The \CFA translator has multiple steps.
-The following flags control how the tranlator works, the stages run, and printing within a stage.
-The majority of these flags are used by \CFA developers, but some are occasionally useful to programmers.
-\begin{description}[topsep=5pt,itemsep=0pt,parsep=0pt]
-\item
-\Indexc{-h}\index{translator option!-h@{©-h©}}, \Indexc{--help}\index{translator option!--help@{©--help©}} \, print help message
-\item
-\Indexc{-l}\index{translator option!-l@{©-l©}}, \Indexc{--libcfa}\index{translator option!--libcfa@{©--libcfa©}} \, generate libcfa.c
-\item
-\Indexc{-L}\index{translator option!-L@{©-L©}}, \Indexc{--linemarks}\index{translator option!--linemarks@{©--linemarks©}} \, generate line marks
-\item
-\Indexc{-m}\index{translator option!-m@{©-m©}}, \Indexc{--no-main}\index{translator option!--no-main@{©--no-main©}} \, do not replace main
-\item
-\Indexc{-N}\index{translator option!-N@{©-N©}}, \Indexc{--no-linemarks}\index{translator option!--no-linemarks@{©--no-linemarks©}} \, do not generate line marks
-\item
-\Indexc{-n}\index{translator option!-n@{©-n©}}, \Indexc{--no-prelude}\index{translator option!--no-prelude@{©--no-prelude©}} \, do not read prelude
-\item
-\Indexc{-p}\index{translator option!-p@{©-p©}}, \Indexc{--prototypes}\index{translator option!--prototypes@{©--prototypes©}} \, generate prototypes for prelude functions
-\item
-\Indexc{-P}\index{translator option!-P@{©-P©}}, \Indexc{--print}\index{translator option!--print@{©--print©}} \, one of:
-\begin{description}[topsep=0pt,itemsep=0pt,parsep=0pt]
-\item
-\Indexc{altexpr}\index{translator option!-P@{©-P©}!©altexpr©}\index{translator option!--print@{©-print©}!©altexpr©} \, alternatives for expressions
-\item
-\Indexc{ascodegen}\index{translator option!-P@{©-P©}!©ascodegen©}\index{translator option!--print@{©-print©}!©ascodegen©} \, as codegen rather than AST
-\item
-\Indexc{ast}\index{translator option!-P@{©-P©}!©ast©}\index{translator option!--print@{©-print©}!©ast©} \, AST after parsing
-\item
-\Indexc{astdecl}\index{translator option!-P@{©-P©}!©astdecl©}\index{translator option!--print@{©-print©}!©astdecl©} \, AST after declaration validation pass
-\item
-\Indexc{asterr}\index{translator option!-P@{©-P©}!©asterr©}\index{translator option!--print@{©-print©}!©asterr©} \, AST on error
-\item
-\Indexc{astexpr}\index{translator option!-P@{©-P©}!©astexpr©}\index{translator option!--print@{©-print©}!©altexpr©} \, AST after expression analysis
-\item
-\Indexc{astgen}\index{translator option!-P@{©-P©}!©astgen©}\index{translator option!--print@{©-print©}!©astgen©} \, AST after instantiate generics
-\item
-\Indexc{box}\index{translator option!-P@{©-P©}!©box©}\index{translator option!--print@{©-print©}!©box©} \, before box step
-\item
-\Indexc{ctordtor}\index{translator option!-P@{©-P©}!©ctordtor©}\index{translator option!--print@{©-print©}!©ctordtor©} \, after ctor/dtor are replaced
-\item
-\Indexc{codegen}\index{translator option!-P@{©-P©}!©codegen©}\index{translator option!--print@{©-print©}!©codegen©} \, before code generation
-\item
-\Indexc{declstats}\index{translator option!-P@{©-P©}!©declstats©}\index{translator option!--print@{©-print©}!©declstats©} \, code property statistics
-\item
-\Indexc{parse}\index{translator option!-P@{©-P©}!©parse©}\index{translator option!--print@{©-print©}!©parse©} \, yacc (parsing) debug information
-\item
-\Indexc{pretty}\index{translator option!-P@{©-P©}!©pretty©}\index{translator option!--print@{©-print©}!©pretty©} \, prettyprint for ascodegen flag
-\item
-\Indexc{resolver}\index{translator option!-P@{©-P©}!©resolver©}\index{translator option!--print@{©-print©}!©resolver©} \, before resolver step
-\item
-\Indexc{rproto}\index{translator option!-P@{©-P©}!©rproto©}\index{translator option!--print@{©-print©}!©rproto©} \, resolver-proto instance
-\item
-\Indexc{rsteps}\index{translator option!-P@{©-P©}!©rsteps©}\index{translator option!--print@{©-print©}!©rsteps©} \, resolver steps
-\item
-\Indexc{symevt}\index{translator option!-P@{©-P©}!©symevt©}\index{translator option!--print@{©-print©}!©symevt©} \, symbol table events
-\item
-\Indexc{tree}\index{translator option!-P@{©-P©}!©tree©}\index{translator option!--print@{©-print©}!©tree©} \, parse tree
-\item
-\Indexc{tuple}\index{translator option!-P@{©-P©}!©tuple©}\index{translator option!--print@{©-print©}!©tuple©} \, after tuple expansion
-\end{description}
-\item
-\Indexc{--prelude-dir} <directory> \, prelude directory for debug/nodebug
-\item
-\Indexc{-S}\index{translator option!-S@{©-S©}!©counters,heap,time,all,none©}, \Indexc{--statistics}\index{translator option!--statistics@{©--statistics©}!©counters,heap,time,all,none©} <option-list> \, enable profiling information:
-\begin{description}[topsep=0pt,itemsep=0pt,parsep=0pt]
-\item
-\Indexc{counters,heap,time,all,none}
-\end{description}
-\item
-\Indexc{-t}\index{translator option!-t@{©-t©}}, \Indexc{--tree}\index{translator option!--tree@{©--tree©}} build in tree
-\end{description}
 \section{Backquote Identifiers}
 …
 As for \Index{division}, there are exponentiation operators for integral and floating types, including the builtin \Index{complex} types.
+Integral exponentiation\index{exponentiation!unsigned integral} is performed with repeated multiplication\footnote{The multiplication computation is $O(\log y)$.} (or shifting if the exponent is 2).
+Overflow from large exponents or negative exponents return zero.
+Floating exponentiation\index{exponentiation!floating} is performed using \Index{logarithm}s\index{exponentiation!logarithm}, so the exponent cannot be negative.
+\begin{cfa}
+sout | 1 ®\® 0 | 1 ®\® 1 | 2 ®\® 8 | -4 ®\® 3 | 5 ®\® 3 | 5 ®\® 32 | 5L ®\® 32 | 5L ®\® 64 | -4 ®\® -3 | -4.0 ®\® -3 | 4.0 ®\® 2.1
+           | (1.0f+2.0fi) ®\® (3.0f+2.0fi);
+1 256 -64 125 ®0® 3273344365508751233 ®0® ®0® -0.015625 18.3791736799526 0.264715-1.1922i
+\end{cfa}
+Note, ©5 ®\® 32© and ©5L ®\® 64© overflow, and ©-4 ®\® -3© is a fraction but stored in an integer so all three computations generate an integral zero.
+Unsigned integral exponentiation\index{exponentiation!unsigned integral} is performed with repeated multiplication\footnote{The multiplication computation is $O(\log y)$.} (or shifting if the base is 2).
+Signed integral exponentiation\index{exponentiation!signed integral} is performed with repeated multiplication (or shifting if the base is 2), but yields a floating result because $x^{-y}=1/x^y$.
+Hence, it is important to designate exponent integral-constants as unsigned or signed: ©3 \ 3u© return an integral result, while ©3 \ 3© returns a floating result.
+Floating exponentiation\index{exponentiation!floating} is performed using \Index{logarithm}s\index{exponentiation!logarithm}, so the base cannot be negative.
+\begin{cfa}
+sout | 2 ®\® 8u | 4 ®\® 3u | -4 ®\® 3u | 4 ®\® -3 | -4 ®\® -3 | 4.0 ®\® 2.1 | (1.0f+2.0fi) ®\® (3.0f+2.0fi);
+64 -64 0.015625 -0.015625 18.3791736799526 0.264715-1.1922i
+\end{cfa}
 Parenthesis are necessary for complex constants or the expression is parsed as ©1.0f+®(®2.0fi \ 3.0f®)®+2.0fi©.
+The exponentiation operator is available for all the basic types, but for user-defined types, only the integral-computation version is available.
+\begin{cfa}
+forall( otype OT | { void ?{}( OT & this, one_t ); OT ?*?( OT, OT ); } )
+OT ?®\®?( OT ep, unsigned int y );
+forall( otype OT | { void ?{}( OT & this, one_t ); OT ?*?( OT, OT ); } )
+OT ?®\®?( OT ep, unsigned long int y );
+\end{cfa}
+The user type ©T© must define multiplication, one, ©1©, and, ©*©.
+The exponentiation operator is available for all the basic types, but for user-defined types, only the integral-computation versions are available.
+For returning an integral value, the user type ©T© must define multiplication, ©*©, and one, ©1©;
+for returning a floating value, an additional divide of type ©T© into a ©double© returning a ©double© (©double ?/?( double, T )©) is necessary for negative exponents.
 …
 \subsection{Loop Control}
+The ©for©/©while©/©do-while© loop-control allows empty or simplified ranges (see Figure~\ref{f:LoopControlExamples}).
+\begin{itemize}
+\item
+The ©for©/©while©/©do-while© loop-control allows empty or simplified ranges.
 An empty conditional implies ©1©.
+\item
+The up-to range ©~©\index{~@©~©} means exclusive range [M,N).
+\item
+The up-to range ©~=©\index{~=@©~=©} means inclusive range [M,N].
+\item
+The down-to range ©-~©\index{-~@©-~©} means exclusive range [N,M).
+\item
+The down-to range ©-~=©\index{-~=@©-~=©} means inclusive range [N,M].
+\item
+©@© means put nothing in this field.
+\item
+The up-to range ©~©\index{~@©~©} means exclusive range [M,N);
+the up-to range ©~=©\index{~=@©~=©} means inclusive range [M,N].
+The down-to range ©-~©\index{-~@©-~©} means exclusive range [N,M);
+the down-to range ©-~=©\index{-~=@©-~=©} means inclusive range [N,M].
 ©0© is the implicit start value;
-\item
 ©1© is the implicit increment value.
-\item
 The up-to range uses ©+=© for increment;
+\item
+The down-to range uses ©-=© for decrement.
+\item
+the down-to range uses ©-=© for decrement.
 The loop index is polymorphic in the type of the start value or comparison value when start is implicitly ©0©.
-\end{itemize}
-\begin{figure}
 \begin{cquote}
 \begin{tabular}{@{}l|l@{}}
 \multicolumn{1}{c|}{loop control} & \multicolumn{1}{c}{output} \\
+\begin{tabular}{@{}ll|l@{}}
+\multicolumn{2}{c|}{loop control} & \multicolumn{1}{c}{output} \\
 \hline
 \begin{cfa}
+sout | nlOff;
+while ®()® { sout | "empty"; break; } sout | nl;
+do { sout | "empty"; break; } while ®()®; sout | nl;
+for ®()® { sout | "empty"; break; } sout | nl;
+for ( ®0® ) { sout | "A"; } sout | "zero" | nl;
+for ( ®1® ) { 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 ( ®0.5 ~ 5.5® ) { sout | "D"; } sout | nl;
+for ( ®5.5 -~ 0.5® ) { sout | "E"; } 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 ( ®i; 0.5 ~ 5.5® ) { sout | i; } sout | nl;
+for ( ®i; 5.5 -~ 0.5® ) { sout | i; } sout | nl;
+for ( ®ui; 2u ~= 10u ~ 2u® ) { sout | ui; } sout | nl;
+for ( ®ui; 10u -~= 2u ~ 2u® ) { sout | ui; } sout | nl;
+while ®()® { sout | "empty"; break; }
+do { sout | "empty"; break; } while ®()®;
+for ®()® { sout | "empty"; break; }
+for ( ®0® ) { sout | "A"; }
+for ( ®1® ) { sout | "A"; }
+for ( ®10® ) { sout | "A"; }
+for ( ®1 ~= 10 ~ 2® ) { sout | "B"; }
+for ( ®10 -~= 1 ~ 2® ) { sout | "C"; }
+for ( ®0.5 ~ 5.5® ) { sout | "D"; }
+for ( ®5.5 -~ 0.5® ) { sout | "E"; }
+for ( ®i; 10® ) { sout | i; }
+for ( ®i; 1 ~= 10 ~ 2® ) { sout | i; }
+for ( ®i; 10 -~= 1 ~ 2® ) { sout | i; }
+for ( ®i; 0.5 ~ 5.5® ) { sout | i; }
+for ( ®i; 5.5 -~ 0.5® ) { sout | i; }
+for ( ®ui; 2u ~= 10u ~ 2u® ) { sout | ui; }
+for ( ®ui; 10u -~= 2u ~ 2u® ) { sout | ui; }
 enum { N = 10 };
 for ( ®N® ) { sout | "N"; } sout | nl;
 for ( ®i; N® ) { sout | i; } sout | nl;
 for ( ®i; N -~ 0® ) { sout | i; } sout | nl;
+for ( ®N® ) { sout | "N"; }
+for ( ®i; N® ) { sout | i; }
+for ( ®i; N -~ 0® ) { sout | i; }
 const int start = 3, comp = 10, inc = 2;
+for ( ®i; start ~ comp ~ inc + 1® ) { sout | i; } sout | nl;
+for ( ®i; 1 ~ @® ) { if ( i > 10 ) break;
+        sout | i; } sout | nl;
+for ( ®i; 10 -~ @® ) { if ( i < 0 ) break;
+        sout | i; } sout | nl;
+for ( ®i; 2 ~ @ ~ 2® ) { if ( i > 10 ) break;
+        sout | i; } sout | nl;
+for ( ®i; 2.1 ~ @ ~ @® ) { if ( i > 10.5 ) break;
+        sout | i; i += 1.7; } sout | nl;
+for ( ®i; 10 -~ @ ~ 2® ) { if ( i < 0 ) break;
+        sout | i; } sout | nl;
+for ( ®i; 12.1 ~ @ ~ @® ) { if ( i < 2.5 ) break;
+        sout | i; i -= 1.7; } sout | nl;
+for ( ®i; 5 : j; -5 ~ @® ) { sout | i | j; } sout | nl;
+for ( ®i; 5 : j; -5 -~ @® ) { sout | i | j; } sout | nl;
+for ( ®i; 5 : j; -5 ~ @ ~ 2® ) { sout | i | j; } sout | nl;
+for ( ®i; 5 : j; -5 -~ @ ~ 2® ) { sout | i | j; } sout | nl;
+for ( ®j; -5 ~ @ : i; 5® ) { sout | i | j; } sout | nl;
+for ( ®j; -5 -~ @ : i; 5® ) { sout | i | j; } sout | nl;
+for ( ®j; -5 ~ @ ~ 2 : i; 5® ) { sout | i | j; } sout | nl;
+for ( ®j; -5 -~ @ ~ 2 : i; 5® ) { sout | i | j; } sout | nl;
+for ( ®j; -5 -~ @ ~ 2 : i; 5 : k; 1.5 ~ @® ) {
+        sout | i | j | k; } sout | nl;
+for ( ®j; -5 -~ @ ~ 2 : k; 1.5 ~ @ : i; 5® ) {
+        sout | i | j | k; } sout | nl;
+for ( ®k; 1.5 ~ @ : j; -5 -~ @ ~ 2 : i; 5® ) {
+        sout | i | j | k; } sout | nl;
+for ( ®i; start ~ comp ~ inc + 1® ) { sout | i; }
 \end{cfa}
+&
 \begin{cfa}
+sout | nl;
+sout | nl;
+sout | nl;
+sout | "zero" | nl;
+sout | nl;
+sout | nl;
+sout | nl;
+sout | nl;
+sout | nl;
+sout | nl;
+sout | nl;
+sout | nl;
+sout | nl;
+sout | nl;
+sout | nl;
+sout | nl;
+sout | nl | nl;
+sout | nl;
+sout | nl;
+sout | nl | nl;
+sout | nl;
+\end{cfa}
+&
+\begin{cfa}
 empty
 empty
 …
 6 9
-2 3 4 5 6 7 8 9 10
-9 8 7 6 5 4 3 2 1 0
-4 6 8 10
-.1 3.8 5.5 7.2 8.9
-8 6 4 2 0
-.1 10.4 8.7 7 5.3 3.6
--5 1 -4 2 -3 3 -2 4 -1
--5 1 -6 2 -7 3 -8 4 -9
--5 1 -3 2 -1 3 1 4 3
--5 1 -7 2 -9 3 -11 4 -13
--5 1 -4 2 -3 3 -2 4 -1
--5 1 -6 2 -7 3 -8 4 -9
--5 1 -3 2 -1 3 1 4 3
--5 1 -7 2 -9 3 -11 4 -13
--5 1.5 1 -7 2.5 2 -9 3.5 3 -11 4.5 4 -13 5.5
--5 1.5 1 -7 2.5 2 -9 3.5 3 -11 4.5 4 -13 5.5
--5 1.5 1 -7 2.5 2 -9 3.5 3 -11 4.5 4 -13 5.5
 \end{cfa}
 \end{tabular}
 \end{cquote}
-\caption{Loop Control Examples}
-\label{f:LoopControlExamples}
-\end{figure}
 …
 \end{cfa}
 Essentially, the return type is wrapped around the routine name in successive layers (like an \Index{onion}).
+While attempting to make the two contexts consistent is a laudable goal, it has not worked out in practice, even though Dennis Richie believed otherwise:
+\begin{quote}
+In spite of its difficulties, I believe that the C's approach to declarations remains plausible, and am comfortable with it; it is a useful unifying principle.~\cite[p.~12]{Ritchie93}
+\end{quote}
+While attempting to make the two contexts consistent is a laudable goal, it has not worked out in practice.
 \CFA provides its own type, variable and routine declarations, using a different syntax.

driver/Makefile.am

r933f32f	r6a9d4b4
19	19
20	20	# applies to both programs
21		AM_CXXFLAGS = @HOST_FLAGS@ -Wall -O2 -g -std=c++14 -I${abs_top_srcdir}/src ~~-I${abs_top_srcdir}/src/include~~
	21	AM_CXXFLAGS = @HOST_FLAGS@ -Wall -O2 -g -std=c++14 -I${abs_top_srcdir}/src
22	22
23	23	# don't install cfa directly

driver/Makefile.in

-              r933f32f
+              r6a9d4b4
 DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)
 ACLOCAL = @ACLOCAL@
+ALLOCA = @ALLOCA@
 AMTAR = @AMTAR@
 AM_DEFAULT_VERBOSITY = @AM_DEFAULT_VERBOSITY@
 …
 # applies to both programs
 AM_CXXFLAGS = @HOST_FLAGS@ -Wall -O2 -g -std=c++14 -I${abs_top_srcdir}/src -I${abs_top_srcdir}/src/include
+AM_CXXFLAGS = @HOST_FLAGS@ -Wall -O2 -g -std=c++14 -I${abs_top_srcdir}/src
 cfa_SOURCES = cfa.cc

driver/cfa.cc

-              r933f32f
+              r6a9d4b4
 // Created On       : Tue Aug 20 13:44:49 2002
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sun Feb 10 08:28:09 2019
 // Update Count     : 281
+// Last Modified On : Tue Jan 15 20:56:03 2019
+// Update Count     : 280
 //
 …
         bool link = true;                                                                       // linking as well as compiling
         bool verbose = false;                                                           // -v flag
+        bool quiet = false;                                                             // -quiet flag
+        bool debug = true;                                                              // -debug flag
+        bool nolib = false;                                                             // -nolib flag
+        bool help = false;                                                              // -help flag
+        bool quiet = false;                                                                     // -quiet flag
+        bool debug = true;                                                                      // -debug flag
+        bool help = false;                                                                      // -help flag
         bool CFA_flag = false;                                                          // -CFA flag
         bool cpp_flag = false;                                                          // -E or -M flag, preprocessor only
 …
                                 debug = true;                                                   // strip the debug flag
                         } else if ( arg == "-nodebug" ) {
+                                debug = false;                                                  // strip the debug flag
+                        } else if ( arg == "-nolib" ) {
+                                nolib = true;                                                   // strip the nodebug flag
+                                debug = false;                                                  // strip the nodebug flag
                         } else if ( arg == "-quiet" ) {
                                 quiet = true;                                                   // strip the quiet flag
 …
                 }  // if
         } // if
         const char * config = nolib ? "nolib" : (debug ? "debug": "nodebug");
+        const char * config = debug ? "debug": "nodebug";
         string libdir = libbase + arch + "-" + config;
         if ( ! nolib && ! dirExists( libdir ) ) {
+        if ( ! dirExists( libdir ) ) {
                 cerr << argv[0] << " internal error, configuration " << config << " not installed." << endl;
                 cerr << "Was looking for " << libdir << endl;
 …
                 args[nargs] = "-Wno-deprecated";
                 nargs += 1;
-#ifdef HAVE_CAST_FUNCTION_TYPE
-                args[nargs] = "-Wno-cast-function-type";
-                nargs += 1;
-#endif // HAVE_CAST_FUNCTION_TYPE
                 if ( ! std_flag ) {                                                             // default c11, if none specified
                         args[nargs] = "-std=gnu11";

libcfa/configure

-              r933f32f
+              r6a9d4b4
-# http://git.savannah.gnu.org/gitweb/?p=autoconf-archive.git;a=blob_plain;f=m4/ax_check_compile_flag.m4
 am__api_version='1.15'
 …
 case $CONFIGURATION in
         "debug"   )
                 CONFIG_CFLAGS="-Og -g"
+                CONFIG_CFLAGS="-O0 -g"
                 CONFIG_CFAFLAGS="-debug"
                 CONFIG_BUILDLIB="yes"
         ;;
         "nodebug" )
                 CONFIG_CFLAGS="-O3 -s"
+                CONFIG_CFLAGS="-O2 -s"
                 CONFIG_CFAFLAGS="-nodebug"
                 CONFIG_BUILDLIB="yes"
         ;;
         "nolib"   )
                 CONFIG_CFLAGS="-O3 -s"
                 CONFIG_CFAFLAGS="-nolib"
+                CONFIG_CFLAGS="-O2 -s"
+                CONFIG_CFAFLAGS="-nodebug"
                 CONFIG_BUILDLIB="no"
-        ;;
-        "profile" )
-                CONFIG_CFLAGS="-O3 -g -fno-omit-frame-pointer"
-                CONFIG_CFAFLAGS="-nodebug"
-                CONFIG_BUILDLIB="yes"
         ;;
         *)
 …
         ;;
 esac
-CONFIG_CFAFLAGS="${CONFIG_CFAFLAGS} ${CFAFLAGS}"

libcfa/configure.ac

-              r933f32f
+              r6a9d4b4
 case $CONFIGURATION in
         "debug"   )
                 CONFIG_CFLAGS="-Og -g"
+                CONFIG_CFLAGS="-O0 -g"
                 CONFIG_CFAFLAGS="-debug"
                 CONFIG_BUILDLIB="yes"
         ;;
         "nodebug" )
                 CONFIG_CFLAGS="-O3 -s"
+                CONFIG_CFLAGS="-O2 -s"
                 CONFIG_CFAFLAGS="-nodebug"
                 CONFIG_BUILDLIB="yes"
         ;;
         "nolib"   )
                 CONFIG_CFLAGS="-O3 -s"
                 CONFIG_CFAFLAGS="-nolib"
+                CONFIG_CFLAGS="-O2 -s"
+                CONFIG_CFAFLAGS="-nodebug"
                 CONFIG_BUILDLIB="no"
-        ;;
-        "profile" )
-                CONFIG_CFLAGS="-O3 -g -fno-omit-frame-pointer"
-                CONFIG_CFAFLAGS="-nodebug"
-                CONFIG_BUILDLIB="yes"
         ;;
         *)
 …
         ;;
 esac
-CONFIG_CFAFLAGS="${CONFIG_CFAFLAGS} ${CFAFLAGS}"
 AC_SUBST(CONFIG_CFLAGS)

libcfa/prelude/builtins.c

-              r933f32f
+              r6a9d4b4
 // Created On       : Fri Jul 21 16:21:03 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Tue Mar 26 23:10:36 2019
 // Update Count     : 95
+// Last Modified On : Sun Aug  5 21:40:38 2018
+// Update Count     : 20
 //
 …
 typedef unsigned long long __cfaabi_abi_exception_type_t;
-#include <limits.h>                                                                             // CHAR_BIT
 #include "../src/virtual.h"
 #include "../src/exception.h"
 …
 // increment/decrement unification
+static inline {
+        forall( dtype DT | { DT & ?+=?( DT &, one_t ); } )
+        DT & ++?( DT & x ) { return x += 1; }
+static inline forall( dtype T | { T& ?+=?( T&, one_t ); } )
+T& ++? ( T& x ) { return x += 1; }
         forall( dtype DT | sized(DT) | { void ?{}( DT &, DT ); void ^?{}( DT & ); DT & ?+=?( DT &, one_t ); } )
         DT & ?++( DT & x ) { DT tmp = x; x += 1; return tmp; }
+static inline forall( dtype T | sized(T) | { void ?{}( T&, T ); void ^?{}( T& ); T& ?+=?( T&, one_t ); } )
+T& ?++ ( T& x ) { T tmp = x; x += 1; return tmp; }
         forall( dtype DT | { DT & ?-=?( DT &, one_t ); } )
         DT & --?( DT & x ) { return x -= 1; }
+static inline forall( dtype T | { T& ?-=?( T&, one_t ); } )
+T& --? ( T& x ) { return x -= 1; }
+        forall( dtype DT | sized(DT) | { void ?{}( DT &, DT ); void ^?{}( DT & ); DT & ?-=?( DT &, one_t ); } )
+        DT & ?--( DT & x ) { DT tmp = x; x -= 1; return tmp; }
+} // distribution
+// universal typed pointer constant
+// 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; }
+static inline forall( dtype T | sized(T) | { void ?{}( T&, T ); void ^?{}( T& ); T& ?-=?( T&, one_t ); } )
+T& ?-- ( T& x ) { T tmp = x; x -= 1; return tmp; }
 // exponentiation operator implementation
 …
 } // extern "C"
+static inline {
+        float ?\?( float x, float y ) { return powf( x, y ); }
+        double ?\?( double x, double y ) { return pow( x, y ); }
+        long double ?\?( long double x, long double y ) { return powl( x, y ); }
+        float _Complex ?\?( float _Complex x, _Complex float y ) { return cpowf(x, y ); }
+        double _Complex ?\?( double _Complex x, _Complex double y ) { return cpow( x, y ); }
+        long double _Complex ?\?( long double _Complex x, _Complex long double y ) { return cpowl( x, y ); }
+} // distribution
+static inline float ?\?( float x, float y ) { return powf( x, y ); }
+static inline double ?\?( double x, double y ) { return pow( x, y ); }
+static inline long double ?\?( long double x, long double y ) { return powl( x, y ); }
+static inline float _Complex ?\?( float _Complex x, _Complex float y ) { return cpowf(x, y ); }
+static inline double _Complex ?\?( double _Complex x, _Complex double y ) { return cpow( x, y ); }
+static inline long double _Complex ?\?( long double _Complex x, _Complex long double y ) { return cpowl( x, y ); }
+#define __CFA_BASE_COMP_1__() if ( ep == 1 ) return 1
+#define __CFA_BASE_COMP_2__() if ( ep == 2 ) return ep << (y - 1)
+#define __CFA_EXP_OVERFLOW__() if ( y >= sizeof(y) * CHAR_BIT ) return 0
+static inline long int ?\?( long int ep, unsigned long int y ) { // disallow negative exponent
+        if ( y == 0 ) return 1;                                                         // base case
+        if ( ep == 2 ) return ep << (y - 1);                            // special case, positive shifting only
+        typeof( ep ) op = 1;                                                            // accumulate odd product
+        for ( ; y > 1; y >>= 1 ) {                                                      // squaring exponentiation, O(log2 y)
+                if ( (y & 1) == 1 ) op *= ep;                                   // odd ?
+                ep *= ep;
+        } // for
+        return ep * op;
+} // ?\?
+#define __CFA_EXP__() \
+        if ( y == 0 ) return 1;                                                         /* convention */ \
+        __CFA_BASE_COMP_1__();                                                          /* base case */ \
+        __CFA_BASE_COMP_2__();                                                          /* special case, positive shifting for integral types */ \
+        __CFA_EXP_OVERFLOW__();                                                         /* immediate overflow, negative exponent > 2^size-1 */ \
+        typeof(ep) op = 1;                                                                      /* accumulate odd product */ \
+        for ( ; y > 1; y >>= 1 ) {                                                      /* squaring exponentiation, O(log2 y) */ \
+                if ( (y & 1) == 1 ) op = op * ep;                               /* odd ? */ \
+                ep = ep * ep; \
+        } \
+        return ep * op
+static inline forall( otype T | { void ?{}( T & this, one_t ); T ?*?( T, T ); } )
+T ?\?( T ep, unsigned long int y ) {
+        if ( y == 0 ) return 1;
+        T op = 1;
+        for ( ; y > 1; y >>= 1 ) {                                                      // squaring exponentiation, O(log2 y)
+                if ( (y & 1) == 1 ) op = op * ep;                               // odd ?
+                ep = ep * ep;
+        } // for
+        return ep * op;
+} // ?\?
+static inline {
+        long int ?\?( int ep, unsigned int y ) { __CFA_EXP__(); }
+        long int ?\?( long int ep, unsigned long int y ) { __CFA_EXP__(); }
+        // unsigned computation may be faster and larger
+        unsigned long int ?\?( unsigned int ep, unsigned int y ) { __CFA_EXP__(); }
+        unsigned long int ?\?( unsigned long int ep, unsigned long int y ) { __CFA_EXP__(); }
+} // distribution
+// unsigned computation may be faster and larger
+static inline unsigned long int ?\?( unsigned long int ep, unsigned long int y ) { // disallow negative exponent
+        if ( y == 0 ) return 1;                                                         // base case
+        if ( ep == 2 ) return ep << (y - 1);                            // special case, positive shifting only
+        typeof( ep ) op = 1;                                                            // accumulate odd product
+        for ( ; y > 1; y >>= 1 ) {                                                      // squaring exponentiation, O(log2 y)
+                if ( (y & 1) == 1 ) op *= ep;                                   // odd ?
+                ep *= ep;
+        } // for
+        return ep * op;
+} // ?\?
+#undef __CFA_BASE_COMP_1__
+#undef __CFA_BASE_COMP_2__
+#undef __CFA_EXP_OVERFLOW__
+#define __CFA_BASE_COMP_1__()
+#define __CFA_BASE_COMP_2__()
+#define __CFA_EXP_OVERFLOW__()
+static inline double ?\?( long int x, signed long int y ) {     // allow negative exponent
+        if ( y >=  0 ) return (double)(x \ (unsigned long int)y);
+        else return 1.0 / x \ (unsigned int)(-y);
+} // ?\?
+static inline forall( otype OT | { void ?{}( OT & this, one_t ); OT ?*?( OT, OT ); } ) {
+        OT ?\?( OT ep, unsigned int y ) { __CFA_EXP__(); }
+        OT ?\?( OT ep, unsigned long int y ) { __CFA_EXP__(); }
+} // distribution
+// FIXME (x \ (unsigned long int)y) relies on X ?\?(T, unsigned long) a function that is neither
+// defined, nor passed as an assertion parameter. Without user-defined conversions, cannot specify
+// X as a type that casts to double, yet it doesn't make sense to write functions with that type
+// signature where X is double.
+#undef __CFA_BASE_COMP_1__
+#undef __CFA_BASE_COMP_2__
+#undef __CFA_EXP_OVERFLOW__
+// static inline forall( otype T | { void ?{}( T & this, one_t ); T ?*?( T, T ); double ?/?( double, T ); } )
+// double ?\?( T x, signed long int y ) {
+//     if ( y >=  0 ) return (double)(x \ (unsigned long int)y);
+//     else return 1.0 / x \ (unsigned long int)(-y);
+// } // ?\?
+static inline {
+        long int ?\=?( long int & x, unsigned long int y ) { x = x \ y; return x; }
+        unsigned long int ?\=?( unsigned long int & x, unsigned long int y ) { x = x \ y; return x; }
+        int ?\=?( int & x, unsigned long int y ) { x = x \ y; return x; }
+        unsigned int ?\=?( unsigned int & x, unsigned long int y ) { x = x \ y; return x; }
+} // distribution
+static inline long int ?\=?( long int & x, unsigned long int y ) { x = x \ y; return x; }
+static inline unsigned long int ?\=?( unsigned long int & x, unsigned long int y ) { x = x \ y; return x; }
+static inline int ?\=?( int & x, unsigned long int y ) { x = x \ y; return x; }
+static inline unsigned int ?\=?( unsigned int & x, unsigned long int y ) { x = x \ y; return x; }
 // Local Variables: //

libcfa/prelude/extras.c

r933f32f	r6a9d4b4
1		#include <stddef.h> // size_t, ptrdiff_t~~, intptr_t, uintptr_t~~
	1	#include <stddef.h> // size_t, ptrdiff_t
2	2	#include <stdint.h> // intX_t, uintX_t, where X is 8, 16, 32, 64
3	3	#include <uchar.h> // char16_t, char32_t

libcfa/prelude/extras.regx

r933f32f	r6a9d4b4
1	1	typedef.* size_t;
2	2	typedef.* ptrdiff_t;
3		~~typedef.* intptr_t;~~
4		~~typedef.* uintptr_t;~~
5	3	typedef.* __int8_t;
6	4	typedef.* __int16_t;

libcfa/prelude/prelude-gen.cc

-              r933f32f
+              r6a9d4b4
-//
-// Cforall Version 1.0.0 Copyright (C) 2018 University of Waterloo
-//
-// The contents of this file are covered under the licence agreement in the
-// file "LICENCE" distributed with Cforall.
-//
-// prelude-gen.cc --
-//
-// Author           : Rob Schluntz and Thierry Delisle
-// Created On       : Sat Feb 16 08:44:58 2019
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Tue Apr  2 17:18:24 2019
-// Update Count     : 37
-//
 #include <algorithm>
 #include <array>
 …
         bool hasComparison;
 } basicTypes[] = {
         { "char"                  , false, true , },
         { "signed char"           , false, true , },
         { "unsigned char"         , false, true , },
+        // { "char"                  , false, true , },
+        // { "signed char"           , false, true , },
+        // { "unsigned char"         , false, true , },
         { "signed short"          , false, true , },
         { "unsigned short"        , false, true , },
 …
 #if defined(__i386__) || defined(__ia64__) || defined(__x86_64__)
         { "__float80"             , true , true , },
         { "__float128"            , true , true , },
+        { "_Float128"             , true , true , },
 #endif
 };
 …
         { "?!=?", false, "signed int", Normal, "" },
         { "?=?", true, "", Normal, "" }, // void * LHS, zero_t RHS ???
+//      { "*?", false, "&", Normal, " | sized(DT)" }, // & ???
+        { "*?", false, "&", Normal, "" }, // & ???
+        { "*?", false, "&", Normal, " | sized(DT)" }, // & ???
         { "?-?", false, "ptrdiff_t", Normal, " | sized(DT)" },
 …
         cout << endl;
         cout << "signed int ?==?( zero_t, zero_t ),     ?!=?( zero_t, zero_t );" << endl;
         cout << "signed int ?==?( one_t, one_t ),       ?!=?( one_t, one_t );" << endl;
         cout << "signed int ?==?( _Bool, _Bool ),       ?!=?( _Bool, _Bool );" << endl;
         cout << "signed int !?( _Bool );" << endl;
+        cout << "signed int ?==?( zero_t, zero_t ),                                                     ?!=?( zero_t, zero_t );" << endl;
+        cout << "signed int ?==?( one_t, one_t ),                                                       ?!=?( one_t, one_t );" << endl;
+        cout << "signed int ?==?( _Bool, _Bool ),                                                       ?!=?( _Bool, _Bool );" << endl;
+        cout << "signed int     !?( _Bool );" << endl;
         for (auto op : arithmeticOperators) {
 …
         cout << "// Arithmetic Constructors //" << endl;
         cout << "/////////////////////////////" << endl;
-        cout << endl;
         auto otype = [](const std::string & type, bool do_volatile = false) {
                 cout << "void ?{} (" << type << " &);" << endl;
                 cout << "void ?{} (" << type << " &, " << type << ");" << endl;
                 cout << type << " ?=? (" << type << " &, " << type << ")";
                 if ( do_volatile ) {
                         cout << ", ?=?(volatile " << type << " &, " << type << ")";
+                cout << "void \t?{} ( " << type << " & );" << endl;
+                cout << "void \t?{} ( " << type << " &, " << type << " );" << endl;
+                cout << type << " \t?=? ( " << type << " &, " << type << " )";
+                if( do_volatile ) {
+                        cout << ", \t?=?( volatile " << type << " &, " << type << " )";
+                }
                 cout << ";" << endl;
                 cout << "void ^?{}( " << type << " & );" << endl;
+                cout << "void \t^?{}( " << type << " & );" << endl;
         };
         otype("zero_t");
-        cout << endl;
         otype("one_t");
-        cout << endl;
         otype("_Bool", true);
+        cout << endl;
+        otype("char", true);
+        otype("signed char", true);
+        otype("unsigned char", true);
         for (auto type : basicTypes) {
+                cout << "void ?{}(" << type.name << " &);" << endl;
+                cout << "void ?{}(" << type.name << " &, " << type.name << ");" << endl;
+                cout << "void ?{}(" << type.name << " &, zero_t);" << endl;
+                cout << "void ?{}(" << type.name << " &, one_t);" << endl;
+                cout << "void  ?{}(" << type.name << " &);" << endl;
+                cout << "void  ?{}(" << type.name << " &, " << type.name << ");" << endl;
                 cout << "void ^?{}(" << type.name << " &);" << endl;
                 cout << endl;
 …
         cout << "// Pointer Constructors //" << endl;
         cout << "//////////////////////////" << endl;
+        cout << endl;
+        cout << "forall(ftype FT) void ?{}( FT *&, FT * );" << endl;
+        cout << "forall(ftype FT) void ?{}( FT * volatile &, FT * );" << endl;
+        cout << "forall(ftype FT) void  ?{}( FT *&, FT * );" << endl;
+        cout << "forall(ftype FT) void  ?{}( FT * volatile &, FT * );" << endl;
         // generate qualifiers
 …
                 for (auto cvq : qualifiersPair) {
                         for (auto is_vol : { "        ", "volatile" }) {
                                 cout << "forall(dtype DT) void ?{}(" << cvq.first << type << " * " << is_vol << " &, " << cvq.second << "DT *);" << endl;
+                                cout << "forall(dtype DT) void  ?{}(" << cvq.first << type << " * " << is_vol << " &, " << cvq.second << "DT *);" << endl;
+                        }
+                }
                 for (auto cvq : qualifiersSingle) {
                         for (auto is_vol : { "        ", "volatile" }) {
                                 cout << "forall(dtype DT) void ?{}(" << cvq << type << " * " << is_vol << " &);" << endl;
+                                cout << "forall(dtype DT) void  ?{}(" << cvq << type << " * " << is_vol << " &);" << endl;
+                        }
                         for (auto is_vol : { "        ", "volatile" }) {
 …
         cout << "forall(ftype FT) FT *                  ?=?( FT *          &, zero_t );" << endl;
         cout << "forall(ftype FT) FT *                  ?=?( FT * volatile &, zero_t );" << endl;
         cout << "forall(ftype FT) void  ?{}( FT *          & );" << endl;
         cout << "forall(ftype FT) void  ^?{}( FT *         & );" << endl;
+        cout << "forall( ftype FT ) void        ?{}( FT *          & );" << endl;
+        cout << "forall( ftype FT ) void        ^?{}( FT *         & );" << endl;
         cout << endl;
 …
         cout << "///////////////////////" << endl;
+        cout << "forall(ftype FT) FT *                  ?=?( FT *&, FT * );" << endl;
+        cout << "forall(ftype FT) FT *                  ?=?( FT * volatile &, FT * );" << endl;
+        cout << "forall(ftype FT) int !?( FT * );" << endl;
+        cout << "forall(ftype FT) signed int ?==?( FT *, FT * );" << endl;
+        cout << "forall(ftype FT) signed int ?!=?( FT *, FT * );" << endl;
+        cout << "forall(ftype FT) FT &           *?( FT * );" << endl;
+        cout << "forall( ftype FT ) FT *                        ?=?( FT *&, FT * );" << endl;
+        cout << "forall( ftype FT ) FT *                        ?=?( FT * volatile &, FT * );" << endl;
+        cout << "forall( ftype FT ) int !?( FT * );" << endl;
+        cout << "forall( ftype FT ) signed int ?==?( FT *, FT * );" << endl;
+        cout << "forall( ftype FT ) signed int ?!=?( FT *, FT * );" << endl;
+        cout << "forall( ftype FT ) FT &                 *?( FT * );" << endl;
         for (auto op : pointerOperators) {
 …
+}
-// Local Variables: //
-// tab-width: 4 //
-// End: //

libcfa/prelude/sync-builtins.cf

-              r933f32f
+              r6a9d4b4
 _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,...);
 …
 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,...);
 …
 #endif
 char __atomic_exchange_n(volatile char *, char, int);
+char __atomic_exchange_n(volatile char *, volatile 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_n(volatile signed char *, volatile 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_n(volatile unsigned char *, volatile 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_n(volatile signed short *, volatile 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_n(volatile unsigned short *, volatile 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_n(volatile signed int *, volatile 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_n(volatile unsigned int *, volatile 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 long int __atomic_exchange_n(volatile signed long long int *, signed long long int, int);
+signed long long int __atomic_exchange_n(volatile signed long long int *, volatile 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_n(volatile unsigned long long int *, volatile 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_n(volatile signed __int128 *, volatile 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_n(volatile unsigned __int128 *, volatile 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
-forall(dtype T) T * __atomic_exchange_n(T * volatile *, T *, int);
-forall(dtype T) void __atomic_exchange(T * volatile *, T * volatile *, T * volatile *, int);
 _Bool __atomic_load_n(const volatile _Bool *, int);
 …
 void __atomic_load(const volatile unsigned __int128 *, volatile unsigned __int128 *, int);
 #endif
-forall(dtype T) T * __atomic_load_n(T * const volatile *, int);
-forall(dtype T) void __atomic_load(T * const volatile *, T **, int);
 _Bool __atomic_compare_exchange_n(volatile char *, char *, char, _Bool, int, int);
 …
 _Bool __atomic_compare_exchange   (volatile unsigned __int128 *, unsigned __int128 *, unsigned __int128 *, _Bool, int, int);
 #endif
-forall(dtype T) _Bool __atomic_compare_exchange_n (T * volatile *, T **, T*, _Bool, int, int);
-forall(dtype T) _Bool __atomic_compare_exchange   (T * volatile *, T **, T**, _Bool, int, int);
 void __atomic_store_n(volatile _Bool *, _Bool, int);
 …
 void __atomic_store(volatile unsigned __int128 *, unsigned __int128 *, int);
 #endif
-forall(dtype T) void __atomic_store_n(T * volatile *, T *, int);
-forall(dtype T) void __atomic_store(T * volatile *, T **, int);
 char __atomic_add_fetch  (volatile char *, char, int);

libcfa/src/Makefile.am

-              r933f32f
+              r6a9d4b4
 prelude.o : prelude.cfa extras.cf gcc-builtins.cf builtins.cf @CFACC@ @CFACPP@
         ${AM_V_GEN}$(CFACOMPILE) -quiet -in-tree -XCFA -l ${<} -c -o ${@}
+        ${AM_V_GEN}@CFACC@ ${AM_CFLAGS} ${CFLAGS} -quiet -in-tree @CONFIG_CFAFLAGS@ -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 -in-tree -XCFA -l ${<} -c -o ${@}
+        @CFACC@ ${AM_CFLAGS} ${CFLAGS} -quiet -in-tree @CONFIG_CFAFLAGS@ -XCFA -l ${<} -c -o ${@}

libcfa/src/Makefile.in

-              r933f32f
+              r6a9d4b4
 prelude.o : prelude.cfa extras.cf gcc-builtins.cf builtins.cf @CFACC@ @CFACPP@
         ${AM_V_GEN}$(CFACOMPILE) -quiet -in-tree -XCFA -l ${<} -c -o ${@}
+        ${AM_V_GEN}@CFACC@ ${AM_CFLAGS} ${CFLAGS} -quiet -in-tree @CONFIG_CFAFLAGS@ -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 -in-tree -XCFA -l ${<} -c -o ${@}
+        @CFACC@ ${AM_CFLAGS} ${CFLAGS} -quiet -in-tree @CONFIG_CFAFLAGS@ -XCFA -l ${<} -c -o ${@}
 #----------------------------------------------------------------------------------------------------------------

libcfa/src/bits/containers.hfa

-              r933f32f
+              r6a9d4b4
         forall(dtype T | is_node(T))
         static inline bool ?!=?( __queue(T) & this, __attribute__((unused)) zero_t zero ) {
+        static inline bool ?!=?( __queue(T) & this, zero_t zero ) {
                 return this.head != 0;
+        }
 …
 //-----------------------------------------------------------------------------
 #ifdef __cforall
         forall(dtype TYPE)
+        forall(dtype TYPE | sized(TYPE))
         #define T TYPE
         #define __getter_t * [T * & next, T * & prev] ( T & )
 …
         forall(dtype T | sized(T))
         static inline bool ?!=?( __dllist(T) & this, __attribute__((unused)) zero_t zero ) {
+        static inline bool ?!=?( __dllist(T) & this, zero_t zero ) {
                 return this.head != 0;
+        }

libcfa/src/concurrency/CtxSwitch-i386.S

-              r933f32f
+              r6a9d4b4
 #define PC_OFFSET       ( 2 * PTR_BYTE )
         .text
+.text
         .align 2
+        .globl CtxSwitch
+        .type  CtxSwitch, @function
+.globl  CtxSwitch
 CtxSwitch:
 …
         movl 4(%esp),%eax
+        // Save floating & SSE control words on the stack.
+        sub    $8,%esp
+        stmxcsr 0(%esp)         // 4 bytes
+        fnstcw  4(%esp)         // 2 bytes
         // Save volatile registers on the stack.
 …
         movl %esp,SP_OFFSET(%eax)
         movl %ebp,FP_OFFSET(%eax)
+//      movl 4(%ebp),%ebx       // save previous eip for debugger
+//      movl %ebx,PC_OFFSET(%eax)
         // Copy the "to" context argument from the stack to register eax
 …
         // argument is now at 8 + 12 = 20(%esp)
         movl 20(%esp),%eax
+        movl 28(%esp),%eax
         // Load new context from the "to" area.
 …
         popl %ebx
+        // Load floating & SSE control words from the stack.
+        fldcw   4(%esp)
+        ldmxcsr 0(%esp)
+        add    $8,%esp
         // Return to thread.
         ret
-        .size  CtxSwitch, .-CtxSwitch
 // Local Variables: //

libcfa/src/concurrency/CtxSwitch-x86_64.S

-              r933f32f
+              r6a9d4b4
 #define SP_OFFSET       ( 0 * PTR_BYTE )
 #define FP_OFFSET       ( 1 * PTR_BYTE )
+#define PC_OFFSET       ( 2 * PTR_BYTE )
+//-----------------------------------------------------------------------------
+// Regular context switch routine which enables switching from one context to anouther
+        .text
+.text
         .align 2
+        .globl CtxSwitch
+        .type  CtxSwitch, @function
+.globl  CtxSwitch
 CtxSwitch:
+        // Save floating & SSE control words on the stack.
+        subq   $8,%rsp
+        stmxcsr 0(%rsp)         // 4 bytes
+        fnstcw  4(%rsp)         // 2 bytes
         // Save volatile registers on the stack.
 …
         popq %r15
+        // Load floating & SSE control words from the stack.
+        fldcw   4(%rsp)
+        ldmxcsr 0(%rsp)
+        addq   $8,%rsp
         // Return to thread.
         ret
-        .size  CtxSwitch, .-CtxSwitch
+//-----------------------------------------------------------------------------
+// Stub used to create new stacks which are ready to be context switched to
+        .text
+.text
         .align 2
+        .globl CtxInvokeStub
+        .type    CtxInvokeStub, @function
+.globl  CtxInvokeStub
 CtxInvokeStub:
         movq %rbx, %rdi
         jmp *%r12
-        .size  CtxInvokeStub, .-CtxInvokeStub
 // Local Variables: //

libcfa/src/concurrency/coroutine.cfa

-              r933f32f
+              r6a9d4b4
 extern "C" {
+        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 *) {
+                abort();
+        }
+        extern void CtxRet( struct __stack_context_t * to ) asm ("CtxRet") __attribute__ ((__noreturn__));
+      void _CtxCoroutine_Unwind(struct _Unwind_Exception * storage) __attribute__ ((__noreturn__));
+      static void _CtxCoroutine_UnwindCleanup(_Unwind_Reason_Code, struct _Unwind_Exception *) __attribute__ ((__noreturn__));
+      static void _CtxCoroutine_UnwindCleanup(_Unwind_Reason_Code, struct _Unwind_Exception *) {
+            abort();
+      }
+}
 …
 // minimum feasible stack size in bytes
 #define MinStackSize 1000
+extern size_t __page_size;                              // architecture pagesize HACK, should go in proper runtime singleton
+void __stack_prepare( __stack_info_t * this, size_t create_size );
+static size_t pageSize = 0;                             // architecture pagesize HACK, should go in proper runtime singleton
 //-----------------------------------------------------------------------------
 // Coroutine ctors and dtors
+void ?{}( __stack_info_t & this, void * storage, size_t storageSize ) {
+        this.storage   = (__stack_t *)storage;
+        // Did we get a piece of storage ?
+        if (this.storage || storageSize != 0) {
+                // We either got a piece of storage or the user asked for a specific size
+                // Immediately create the stack
+                // (This is slightly unintuitive that non-default sized coroutines create are eagerly created
+                // but it avoids that all coroutines carry an unnecessary size)
+                verify( storageSize != 0 );
+                __stack_prepare( &this, storageSize );
+        }
+}
+void ^?{}(__stack_info_t & this) {
+        bool userStack = ((intptr_t)this.storage & 0x1) != 0;
+        if ( ! userStack && this.storage ) {
+                __attribute__((may_alias)) intptr_t * istorage = (intptr_t *)&this.storage;
+                *istorage &= (intptr_t)-1;
+                void * storage = this.storage->limit;
+                __cfaabi_dbg_debug_do(
+                        storage = (char*)(storage) - __page_size;
+                        if ( mprotect( storage, __page_size, PROT_READ | PROT_WRITE ) == -1 ) {
+                                abort( "(coStack_t *)%p.^?{}() : internal error, mprotect failure, error(%d) %s.", &this, errno, strerror( errno ) );
+                        }
+                );
+                __cfaabi_dbg_print_safe("Kernel : Deleting stack %p\n", storage);
+                free( storage );
+        }
+void ?{}( coStack_t & this, void * storage, size_t storageSize ) with( this ) {
+      size               = storageSize == 0 ? 65000 : storageSize; // size of stack
+      this.storage = storage;                                // pointer to stack
+      limit              = NULL;                                   // stack grows towards stack limit
+      base               = NULL;                                   // base of stack
+      context    = NULL;                                   // address of cfa_context_t
+      top                = NULL;                                   // address of top of storage
+      userStack  = storage != NULL;
+}
+void ^?{}(coStack_t & this) {
+      if ( ! this.userStack && this.storage ) {
+            __cfaabi_dbg_debug_do(
+                  if ( mprotect( this.storage, pageSize, PROT_READ | PROT_WRITE ) == -1 ) {
+                        abort( "(coStack_t *)%p.^?{}() : internal error, mprotect failure, error(%d) %s.", &this, errno, strerror( errno ) );
+                  }
+            );
+            free( this.storage );
+      }
+}
 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 = NULL;
         last = NULL;
         cancellation = NULL;
+      (this.stack){storage, storageSize};
+      this.name = name;
+      errno_ = 0;
+      state = Start;
+      starter = NULL;
+      last = NULL;
+      cancellation = NULL;
+}
 void ^?{}(coroutine_desc& this) {
         if(this.state != Halted && this.state != Start) {
                 coroutine_desc * src = TL_GET( this_thread )->curr_cor;
                 coroutine_desc * dst = &this;
                 struct _Unwind_Exception storage;
                 storage.exception_class = -1;
                 storage.exception_cleanup = _CtxCoroutine_UnwindCleanup;
                 this.cancellation = &storage;
                 this.last = src;
                 // not resuming self ?
                 if ( src == dst ) {
                         abort( "Attempt by coroutine %.256s (%p) to terminate itself.\n", src->name, src );
+                }
                 CoroutineCtxSwitch( src, dst );
+        }
+      if(this.state != Halted && this.state != Start) {
+            coroutine_desc * src = TL_GET( this_coroutine );
+            coroutine_desc * dst = &this;
+            struct _Unwind_Exception storage;
+            storage.exception_class = -1;
+            storage.exception_cleanup = _CtxCoroutine_UnwindCleanup;
+            this.cancellation = &storage;
+            this.last = src;
+              // not resuming self ?
+              if ( src == dst ) {
+                      abort( "Attempt by coroutine %.256s (%p) to terminate itself.\n", src->name, src );
+            }
+              CoroutineCtxSwitch( src, dst );
+      }
+}
 …
 forall(dtype T | is_coroutine(T))
 void prime(T& cor) {
+        coroutine_desc* this = get_coroutine(cor);
+        assert(this->state == Start);
+        this->state = Primed;
+        resume(cor);
+}
+[void *, size_t] __stack_alloc( size_t storageSize ) {
+        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;
+        // If we are running debug, we also need to allocate a guardpage to catch stack overflows.
+        void * storage;
+        __cfaabi_dbg_debug_do(
+                storage = memalign( __page_size, size + __page_size );
+        );
+        __cfaabi_dbg_no_debug_do(
+                storage = (void*)malloc(size);
+        );
+        __cfaabi_dbg_print_safe("Kernel : Created stack %p of size %zu\n", storage, size);
+        __cfaabi_dbg_debug_do(
+                if ( mprotect( storage, __page_size, PROT_NONE ) == -1 ) {
+                        abort( "__stack_alloc : internal error, mprotect failure, error(%d) %s.", (int)errno, strerror( (int)errno ) );
+                }
+                storage = (void *)(((intptr_t)storage) + __page_size);
+        );
+        verify( ((intptr_t)storage & (libAlign() - 1)) == 0ul );
+        return [storage, size];
+}
+void __stack_prepare( __stack_info_t * this, size_t create_size ) {
+        static const size_t stack_data_size = libCeiling( sizeof(__stack_t), 16 ); // minimum alignment
+        bool userStack;
+        void * storage;
+        size_t size;
+        if ( !this->storage ) {
+                userStack = false;
+                [storage, size] = __stack_alloc( create_size );
+        } else {
+                userStack = true;
+                __cfaabi_dbg_print_safe("Kernel : stack obj %p using user stack %p(%zd bytes)\n", this, this->storage, (intptr_t)this->storage->limit - (intptr_t)this->storage->base);
+                // The stack must be aligned, advance the pointer to the next align data
+                storage = (void*)libCeiling( (intptr_t)this->storage, libAlign());
+                // The size needs to be shrinked to fit all the extra data structure and be aligned
+                ptrdiff_t diff = (intptr_t)storage - (intptr_t)this->storage;
+                size = libFloor(create_size - stack_data_size - diff, libAlign());
+        } // if
+        assertf( size >= MinStackSize, "Stack size %zd provides less than minimum of %d bytes for a stack.", size, MinStackSize );
+        this->storage = (__stack_t *)((intptr_t)storage + size);
+        this->storage->limit = storage;
+        this->storage->base  = (void*)((intptr_t)storage + size);
+        __attribute__((may_alias)) intptr_t * istorage = (intptr_t*)&this->storage;
+        *istorage |= userStack ? 0x1 : 0x0;
+      coroutine_desc* this = get_coroutine(cor);
+      assert(this->state == Start);
+      this->state = Primed;
+      resume(cor);
+}
+// Wrapper for co
+void CoroutineCtxSwitch(coroutine_desc* src, coroutine_desc* dst) {
+      // Safety note : This could cause some false positives due to preemption
+      verify( TL_GET( preemption_state.enabled ) || TL_GET( this_processor )->do_terminate );
+      disable_interrupts();
+      // set state of current coroutine to inactive
+      src->state = src->state == Halted ? Halted : Inactive;
+      // set new coroutine that task is executing
+      kernelTLS.this_coroutine = dst;
+      // context switch to specified coroutine
+      assert( src->stack.context );
+      CtxSwitch( src->stack.context, dst->stack.context );
+      // when CtxSwitch returns we are back in the src coroutine
+      // set state of new coroutine to active
+      src->state = Active;
+      enable_interrupts( __cfaabi_dbg_ctx );
+      // Safety note : This could cause some false positives due to preemption
+      verify( TL_GET( preemption_state.enabled ) || TL_GET( this_processor )->do_terminate );
+      if( unlikely(src->cancellation != NULL) ) {
+            _CtxCoroutine_Unwind(src->cancellation);
+      }
+} //ctxSwitchDirect
+void create_stack( coStack_t* this, unsigned int storageSize ) with( *this ) {
+      //TEMP HACK do this on proper kernel startup
+      if(pageSize == 0ul) pageSize = sysconf( _SC_PAGESIZE );
+      size_t cxtSize = libCeiling( sizeof(machine_context_t), 8 ); // minimum alignment
+      if ( !storage ) {
+            __cfaabi_dbg_print_safe("Kernel : Creating stack of size %zu for stack obj %p\n", cxtSize + size + 8, this);
+            userStack = false;
+            size = libCeiling( storageSize, 16 );
+            // use malloc/memalign because "new" raises an exception for out-of-memory
+            // assume malloc has 8 byte alignment so add 8 to allow rounding up to 16 byte alignment
+            __cfaabi_dbg_debug_do( storage = memalign( pageSize, cxtSize + size + pageSize ) );
+            __cfaabi_dbg_no_debug_do( storage = malloc( cxtSize + size + 8 ) );
+            __cfaabi_dbg_debug_do(
+                  if ( mprotect( storage, pageSize, PROT_NONE ) == -1 ) {
+                        abort( "(uMachContext &)%p.createContext() : internal error, mprotect failure, error(%d) %s.", this, (int)errno, strerror( (int)errno ) );
+                  } // if
+            );
+            if ( (intptr_t)storage == 0 ) {
+                  abort( "Attempt to allocate %zd bytes of storage for coroutine or task execution-state but insufficient memory available.", size );
+            } // if
+            __cfaabi_dbg_debug_do( limit = (char *)storage + pageSize );
+            __cfaabi_dbg_no_debug_do( limit = (char *)libCeiling( (unsigned long)storage, 16 ) ); // minimum alignment
+      } else {
+            __cfaabi_dbg_print_safe("Kernel : stack obj %p using user stack %p(%u bytes)\n", this, storage, storageSize);
+            assertf( ((size_t)storage & (libAlign() - 1)) == 0ul, "Stack storage %p for task/coroutine must be aligned on %d byte boundary.", storage, (int)libAlign() );
+            userStack = true;
+            size = storageSize - cxtSize;
+            if ( size % 16 != 0u ) size -= 8;
+            limit = (char *)libCeiling( (unsigned long)storage, 16 ); // minimum alignment
+      } // if
+      assertf( size >= MinStackSize, "Stack size %zd provides less than minimum of %d bytes for a stack.", size, MinStackSize );
+      base = (char *)limit + size;
+      context = base;
+      top = (char *)context + cxtSize;
+}
 …
 // is not inline (We can't inline Cforall in C)
 extern "C" {
+        void __suspend_internal(void) {
+                suspend();
+        }
+        void __leave_coroutine( coroutine_desc * src ) {
+                coroutine_desc * starter = src->cancellation != 0 ? src->last : src->starter;
+                src->state = Halted;
+                assertf( starter != 0,
+                        "Attempt to suspend/leave coroutine \"%.256s\" (%p) that has never been resumed.\n"
+                        "Possible cause is a suspend executed in a member called by a coroutine user rather than by the coroutine main.",
+                        src->name, src );
+                assertf( starter->state != Halted,
+                        "Attempt by coroutine \"%.256s\" (%p) to suspend/leave back to terminated coroutine \"%.256s\" (%p).\n"
+                        "Possible cause is terminated coroutine's main routine has already returned.",
+                        src->name, src, starter->name, starter );
+                CoroutineCtxSwitch( src, starter );
+        }
+      void __suspend_internal(void) {
+            suspend();
+      }
+      void __leave_coroutine() {
+            coroutine_desc * src = TL_GET( this_coroutine ); // optimization
+            coroutine_desc * starter = src->cancellation != 0 ? src->last : src->starter;
+            src->state = Halted;
+            assertf( starter != 0,
+                  "Attempt to suspend/leave coroutine \"%.256s\" (%p) that has never been resumed.\n"
+                  "Possible cause is a suspend executed in a member called by a coroutine user rather than by the coroutine main.",
+                  src->name, src );
+            assertf( starter->state != Halted,
+                  "Attempt by coroutine \"%.256s\" (%p) to suspend/leave back to terminated coroutine \"%.256s\" (%p).\n"
+                  "Possible cause is terminated coroutine's main routine has already returned.",
+                  src->name, src, starter->name, starter );
+            CoroutineCtxSwitch( src, starter );
+      }
+}

libcfa/src/concurrency/coroutine.hfa

-              r933f32f
+              r6a9d4b4
 //-----------------------------------------------------------------------------
 // Public coroutine API
 static inline void suspend(void);
+static inline void suspend();
 forall(dtype T | is_coroutine(T))
 static inline T & resume(T & cor);
+static inline void resume(T & cor);
 forall(dtype T | is_coroutine(T))
 …
       forall(dtype T | is_coroutine(T))
       void CtxStart(T * this, void ( *invoke)(T *));
-        extern void _CtxCoroutine_Unwind(struct _Unwind_Exception * storage, struct coroutine_desc *) __attribute__ ((__noreturn__));
-        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 CoroutineCtxSwitch(coroutine_desc* src, coroutine_desc* dst) {
+        // set state of current coroutine to inactive
+        src->state = src->state == Halted ? Halted : Inactive;
+        // set new coroutine that task is executing
+        TL_GET( this_thread )->curr_cor = dst;
+        // context switch to specified coroutine
+        verify( dst->context.SP );
+        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 != NULL) ) {
+                _CtxCoroutine_Unwind(src->cancellation, src);
+        }
+}
+extern void __stack_prepare   ( __stack_info_t * this, size_t size /* ignored if storage already allocated */);
+extern void CoroutineCtxSwitch(coroutine_desc * src, coroutine_desc * dst);
+extern void create_stack( coStack_t * this, unsigned int storageSize );
 // Suspend implementation inlined for performance
 static inline void suspend(void) {
+static inline void suspend() {
         // 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_desc * src = TL_GET( this_thread )->curr_cor;
+        coroutine_desc * src = TL_GET( this_coroutine );
         assertf( src->last != 0,
 …
 // Resume implementation inlined for performance
 forall(dtype T | is_coroutine(T))
 static inline T & resume(T & cor) {
+static inline void resume(T & cor) {
         // 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_desc * src = TL_GET( this_thread )->curr_cor;
+        coroutine_desc * src = TL_GET( this_coroutine );
         coroutine_desc * dst = get_coroutine(cor);
         if( unlikely(dst->context.SP == NULL) ) {
                 __stack_prepare(&dst->stack, 65000);
+        if( unlikely(!dst->stack.base) ) {
+                create_stack(&dst->stack, dst->stack.size);
                 CtxStart(&cor, CtxInvokeCoroutine);
+        }
 …
         // always done for performance testing
         CoroutineCtxSwitch( src, dst );
-        return cor;
+}
 …
         // will also migrate which means this value will
         // stay in syn with the TLS
         coroutine_desc * src = TL_GET( this_thread )->curr_cor;
+        coroutine_desc * src = TL_GET( this_coroutine );
         // not resuming self ?

libcfa/src/concurrency/invoke.c

-              r933f32f
+              r6a9d4b4
 extern void __suspend_internal(void);
 extern void __leave_coroutine( struct coroutine_desc * );
 extern void __finish_creation( struct thread_desc * );
+extern void __leave_coroutine(void);
+extern void __finish_creation(void);
 extern void __leave_thread_monitor( struct thread_desc * this );
 extern void disable_interrupts();
 …
         cor->state = Active;
+        enable_interrupts( __cfaabi_dbg_ctx );
         main( this );
         //Final suspend, should never return
         __leave_coroutine( cor );
+        __leave_coroutine();
         __cabi_abort( "Resumed dead coroutine" );
+}
 …
         __attribute((__unused__)) struct _Unwind_Exception * unwind_exception,
         __attribute((__unused__)) struct _Unwind_Context * context,
         void * param
+        __attribute((__unused__)) void * param
 ) {
         if( actions & _UA_END_OF_STACK  ) {
                 // We finished unwinding the coroutine,
                 // leave it
                 __leave_coroutine( param );
+                __leave_coroutine();
                 __cabi_abort( "Resumed dead coroutine" );
+        }
 …
+}
 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 );
+void _CtxCoroutine_Unwind(struct _Unwind_Exception * storage) __attribute__ ((__noreturn__));
+void _CtxCoroutine_Unwind(struct _Unwind_Exception * storage) {
+        _Unwind_Reason_Code ret = _Unwind_ForcedUnwind( storage, _CtxCoroutine_UnwindStop, NULL );
         printf("UNWIND ERROR %d after force unwind\n", ret);
         abort();
 …
         void *this
 ) {
+        // First suspend, once the thread arrives here,
+        // the function pointer to main can be invalidated without risk
+        __finish_creation();
         // 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 );
+        thrd->self_cor.last = NULL;
         // Officially start the thread by enabling preemption
 …
         void (*invoke)(void *)
 ) {
+        struct coroutine_desc * cor = get_coroutine( this );
+        struct __stack_t * stack = cor->stack.storage;
+        struct coStack_t* stack = &get_coroutine( this )->stack;
 #if defined( __i386 )
         struct FakeStack {
+            void *fixedRegisters[3];              // fixed registers ebx, edi, esi (popped on 1st uSwitch, values unimportant)
+            void *fixedRegisters[3];                    // fixed registers ebx, edi, esi (popped on 1st uSwitch, values unimportant)
+            uint32_t mxcr;                        // SSE Status and Control bits (control bits are preserved across function calls)
+            uint16_t fcw;                         // X97 FPU control word (preserved across function calls)
             void *rturn;                          // where to go on return from uSwitch
             void *dummyReturn;                    // fake return compiler would have pushed on call to uInvoke
             void *argument[3];                    // for 16-byte ABI, 16-byte alignment starts here
             void *padding;                        // padding to force 16-byte alignment, as "base" is 16-byte aligned
+            void *dummyReturn;                          // fake return compiler would have pushed on call to uInvoke
+            void *argument[3];                          // for 16-byte ABI, 16-byte alignment starts here
+            void *padding;                              // padding to force 16-byte alignment, as "base" is 16-byte aligned
         };
         cor->context.SP = (char *)stack->base - sizeof( struct FakeStack );
         cor->context.FP = NULL;         // terminate stack with NULL fp
+        ((struct machine_context_t *)stack->context)->SP = (char *)stack->base - sizeof( struct FakeStack );
+        ((struct machine_context_t *)stack->context)->FP = NULL;                // terminate stack with NULL fp
         struct FakeStack *fs = (struct FakeStack *)cor->context.SP;
         fs->dummyReturn = NULL;
         fs->argument[0] = this;     // argument to invoke
         fs->rturn = invoke;
+        ((struct FakeStack *)(((struct machine_context_t *)stack->context)->SP))->dummyReturn = NULL;
+        ((struct FakeStack *)(((struct machine_context_t *)stack->context)->SP))->argument[0] = this;     // argument to invoke
+        ((struct FakeStack *)(((struct machine_context_t *)stack->context)->SP))->rturn = invoke;
+        ((struct FakeStack *)(((struct machine_context_t *)stack->context)->SP))->mxcr = 0x1F80; //Vol. 2A 3-520
+        ((struct FakeStack *)(((struct machine_context_t *)stack->context)->SP))->fcw = 0x037F;  //Vol. 1 8-7
 #elif defined( __x86_64 )
 …
         struct FakeStack {
                 void *fixedRegisters[5];            // fixed registers rbx, r12, r13, r14, r15
+                uint32_t mxcr;                      // SSE Status and Control bits (control bits are preserved across function calls)
+                uint16_t fcw;                       // X97 FPU control word (preserved across function calls)
                 void *rturn;                        // where to go on return from uSwitch
                 void *dummyReturn;                  // NULL return address to provide proper alignment
         };
         cor->context.SP = (char *)stack->base - sizeof( struct FakeStack );
         cor->context.FP = NULL;         // terminate stack with NULL fp
+        ((struct machine_context_t *)stack->context)->SP = (char *)stack->base - sizeof( struct FakeStack );
+        ((struct machine_context_t *)stack->context)->FP = NULL;                // terminate stack with NULL fp
         struct FakeStack *fs = (struct FakeStack *)cor->context.SP;
         fs->dummyReturn = NULL;
         fs->rturn = CtxInvokeStub;
         fs->fixedRegisters[0] = this;
         fs->fixedRegisters[1] = invoke;
+        ((struct FakeStack *)(((struct machine_context_t *)stack->context)->SP))->dummyReturn = NULL;
+        ((struct FakeStack *)(((struct machine_context_t *)stack->context)->SP))->rturn = CtxInvokeStub;
+        ((struct FakeStack *)(((struct machine_context_t *)stack->context)->SP))->fixedRegisters[0] = this;
+        ((struct FakeStack *)(((struct machine_context_t *)stack->context)->SP))->fixedRegisters[1] = invoke;
+        ((struct FakeStack *)(((struct machine_context_t *)stack->context)->SP))->mxcr = 0x1F80; //Vol. 2A 3-520
+        ((struct FakeStack *)(((struct machine_context_t *)stack->context)->SP))->fcw = 0x037F;  //Vol. 1 8-7
 #elif defined( __ARM_ARCH )
 …
         };
         cor->context.SP = (char *)stack->base - sizeof( struct FakeStack );
         cor->context.FP = NULL;
+        ((struct machine_context_t *)stack->context)->SP = (char *)stack->base - sizeof( struct FakeStack );
+        ((struct machine_context_t *)stack->context)->FP = NULL;
         struct FakeStack *fs = (struct FakeStack *)cor->context.SP;
+        struct FakeStack *fs = (struct FakeStack *)((struct machine_context_t *)stack->context)->SP;
         fs->intRegs[8] = CtxInvokeStub;

libcfa/src/concurrency/invoke.h

-              r933f32f
+              r6a9d4b4
                 extern thread_local struct KernelThreadData {
+                        struct coroutine_desc * volatile this_coroutine;
                         struct thread_desc    * volatile this_thread;
                         struct processor      * volatile this_processor;
 …
                 } kernelTLS __attribute__ ((tls_model ( "initial-exec" )));
+        }
+        static inline struct coroutine_desc * volatile active_coroutine() { return TL_GET( this_coroutine ); }
+        static inline struct thread_desc    * volatile active_thread   () { return TL_GET( this_thread    ); }
+        static inline struct processor      * volatile active_processor() { return TL_GET( this_processor ); } // UNSAFE
         #endif
+        struct __stack_context_t {
+                void * SP;
+                void * FP;
+        };
+        // low adresses  :           +----------------------+ <- start of allocation
+        //                           |  optional guard page |
+        //                           +----------------------+ <- __stack_t.limit
+        //                           |                      |
+        //                           |       /\ /\ /\       |
+        //                           |       || || ||       |
+        //                           |                      |
+        //                           |    program  stack    |
+        //                           |                      |
+        // __stack_info_t.storage -> +----------------------+ <- __stack_t.base
+        //                           |      __stack_t       |
+        // high adresses :           +----------------------+ <- end of allocation
+        struct __stack_t {
+                // stack grows towards stack limit
+                void * limit;
+                // base of stack
+                void * base;
+        };
+        struct __stack_info_t {
+                // pointer to stack
+                struct __stack_t * storage;
+        struct coStack_t {
+                size_t size;                                                                    // size of stack
+                void * storage;                                                                 // pointer to stack
+                void * limit;                                                                   // stack grows towards stack limit
+                void * base;                                                                    // base of stack
+                void * context;                                                                 // address of cfa_context_t
+                void * top;                                                                             // address of top of storage
+                bool userStack;                                                                 // whether or not the user allocated the stack
         };
 …
         struct coroutine_desc {
-                // context that is switch during a CtxSwitch
-                struct __stack_context_t context;
                 // stack information of the coroutine
                 struct __stack_info_t stack;
                 // textual name for coroutine/task
+                struct coStack_t stack;
+                // textual name for coroutine/task, initialized by uC++ generated code
                 const char * name;
+                // copy of global UNIX variable errno
+                int errno_;
                 // current execution status for coroutine
                 enum coroutine_state state;
                 // first coroutine to resume this one
                 struct coroutine_desc * starter;
 …
         struct thread_desc {
                 // Core threading fields
-                // context that is switch during a CtxSwitch
-                struct __stack_context_t context;
-                // current execution status for coroutine
-                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_desc  self_cor;
 …
                         struct thread_desc * prev;
                 } node;
+        };
+        #ifdef __cforall
+        extern "Cforall" {
+                static inline struct coroutine_desc * active_coroutine() { return TL_GET( this_thread )->curr_cor; }
+                static inline struct thread_desc    * active_thread   () { return TL_GET( this_thread    ); }
+                static inline struct processor      * active_processor() { return TL_GET( this_processor ); } // UNSAFE
+     };
+     #ifdef __cforall
+     extern "Cforall" {
                 static inline thread_desc * & get_next( thread_desc & this ) {
                         return this.next;
 …
         // assembler routines that performs the context 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");
+        void CtxSwitch( void * from, void * to ) asm ("CtxSwitch");
+        #if   defined( __i386 )
+        #define CtxGet( ctx ) __asm__ ( \
+                        "movl %%esp,%0\n"   \
+                        "movl %%ebp,%1\n"   \
+                : "=rm" (ctx.SP), "=rm" (ctx.FP) )
+        #elif defined( __x86_64 )
+        #define CtxGet( ctx ) __asm__ ( \
+                        "movq %%rsp,%0\n"   \
+                        "movq %%rbp,%1\n"   \
+                : "=rm" (ctx.SP), "=rm" (ctx.FP) )
+        #elif defined( __ARM_ARCH )
+        #define CtxGet( ctx ) __asm__ ( \
+                        "mov %0,%%sp\n"   \
+                        "mov %1,%%r11\n"   \
+                : "=rm" (ctx.SP), "=rm" (ctx.FP) )
+        #else
+                #error unknown hardware architecture
+        #endif
 #endif //_INVOKE_PRIVATE_H_

libcfa/src/concurrency/kernel.cfa

-              r933f32f
+              r6a9d4b4
 #include "invoke.h"
-//-----------------------------------------------------------------------------
-// Some assembly required
-#if   defined( __i386 )
-        #define CtxGet( ctx )        \
-                __asm__ volatile (     \
-                        "movl %%esp,%0\n"\
-                        "movl %%ebp,%1\n"\
-                        : "=rm" (ctx.SP),\
-                                "=rm" (ctx.FP) \
+                )
-        // mxcr : SSE Status and Control bits (control bits are preserved across function calls)
-        // fcw  : X87 FPU control word (preserved across function calls)
-        #define __x87_store         \
-                uint32_t __mxcr;      \
-                uint16_t __fcw;       \
-                __asm__ volatile (    \
-                        "stmxcsr %0\n"  \
-                        "fnstcw  %1\n"  \
-                        : "=m" (__mxcr),\
-                                "=m" (__fcw)  \
+                )
-        #define __x87_load         \
-                __asm__ volatile (   \
-                        "fldcw  %1\n"  \
-                        "ldmxcsr %0\n" \
-                        ::"m" (__mxcr),\
-                                "m" (__fcw)  \
+                )
-#elif defined( __x86_64 )
-        #define CtxGet( ctx )        \
-                __asm__ volatile (     \
-                        "movq %%rsp,%0\n"\
-                        "movq %%rbp,%1\n"\
-                        : "=rm" (ctx.SP),\
-                                "=rm" (ctx.FP) \
+                )
-        #define __x87_store         \
-                uint32_t __mxcr;      \
-                uint16_t __fcw;       \
-                __asm__ volatile (    \
-                        "stmxcsr %0\n"  \
-                        "fnstcw  %1\n"  \
-                        : "=m" (__mxcr),\
-                                "=m" (__fcw)  \
+                )
-        #define __x87_load          \
-                __asm__ volatile (    \
-                        "fldcw  %1\n"   \
-                        "ldmxcsr %0\n"  \
-                        :: "m" (__mxcr),\
-                                "m" (__fcw)  \
+                )
-#elif defined( __ARM_ARCH )
-#define CtxGet( ctx ) __asm__ ( \
-                "mov %0,%%sp\n"   \
-                "mov %1,%%r11\n"   \
-        : "=rm" (ctx.SP), "=rm" (ctx.FP) )
-#else
-        #error unknown hardware architecture
-#endif
-//-----------------------------------------------------------------------------
 //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 ) ));
 …
 //-----------------------------------------------------------------------------
 // Kernel storage
 KERNEL_STORAGE(cluster,         mainCluster);
 KERNEL_STORAGE(processor,       mainProcessor);
 KERNEL_STORAGE(thread_desc,     mainThread);
 KERNEL_STORAGE(__stack_t,       mainThreadCtx);
+KERNEL_STORAGE(cluster,           mainCluster);
+KERNEL_STORAGE(processor,         mainProcessor);
+KERNEL_STORAGE(thread_desc,       mainThread);
+KERNEL_STORAGE(machine_context_t, mainThreadCtx);
 cluster     * mainCluster;
 …
 struct { __dllist_t(cluster) list; __spinlock_t lock; } __cfa_dbg_global_clusters;
+}
-size_t __page_size = 0;
 //-----------------------------------------------------------------------------
 …
         NULL,
         NULL,
+        NULL,
         { 1, false, false }
 };
 …
 // Struct to steal stack
 struct current_stack_info_t {
+        __stack_t * storage;            // pointer to stack object
+        machine_context_t ctx;
+        unsigned int size;              // size of stack
         void *base;                             // base of stack
+        void *storage;                  // pointer to stack
         void *limit;                    // stack grows towards stack limit
         void *context;                  // address of cfa_context_t
+        void *top;                              // address of top of storage
 };
 void ?{}( current_stack_info_t & this ) {
         __stack_context_t ctx;
         CtxGet( ctx );
         this.base = ctx.FP;
+        CtxGet( this.ctx );
+        this.base = this.ctx.FP;
+        this.storage = this.ctx.SP;
         rlimit r;
         getrlimit( RLIMIT_STACK, &r);
         size_t size = r.rlim_cur;
         this.limit = (void *)(((intptr_t)this.base) - size);
+        this.size = r.rlim_cur;
+        this.limit = (void *)(((intptr_t)this.base) - this.size);
         this.context = &storage_mainThreadCtx;
+        this.top = this.base;
+}
 //-----------------------------------------------------------------------------
 // Main thread construction
+void ?{}( coStack_t & this, current_stack_info_t * info) with( this ) {
+        size      = info->size;
+        storage   = info->storage;
+        limit     = info->limit;
+        base      = info->base;
+        context   = info->context;
+        top       = info->top;
+        userStack = true;
+}
 void ?{}( coroutine_desc & this, current_stack_info_t * info) with( this ) {
+        stack.storage = info->storage;
+        with(*stack.storage) {
+                limit     = info->limit;
+                base      = info->base;
+        }
+        __attribute__((may_alias)) intptr_t * istorage = (intptr_t*) &stack.storage;
+        *istorage |= 0x1;
+        stack{ info };
         name = "Main Thread";
+        errno_ = 0;
         state = Start;
         starter = NULL;
-        last = NULL;
-        cancellation = NULL;
+}
 void ?{}( thread_desc & this, current_stack_info_t * info) with( this ) {
-        state = Start;
         self_cor{ info };
         curr_cor = &self_cor;
 …
+}
-static int * __volatile_errno() __attribute__((noinline));
-static int * __volatile_errno() { asm(""); return &errno; }
 // KERNEL ONLY
 // runThread runs a thread by context switching
 // from the processor coroutine to the target thread
+static void runThread(processor * this, thread_desc * thrd_dst) {
+static void runThread(processor * this, thread_desc * dst) {
+        assert(dst->curr_cor);
         coroutine_desc * proc_cor = get_coroutine(this->runner);
+        coroutine_desc * thrd_cor = dst->curr_cor;
         // Reset the terminating actions here
 …
         // Update global state
+        kernelTLS.this_thread = thrd_dst;
+        // 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;
+        kernelTLS.this_thread = dst;
+        // Context Switch to the thread
+        ThreadCtxSwitch(proc_cor, thrd_cor);
+        // when ThreadCtxSwitch returns we are back in the processor coroutine
+}
 …
 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;
+        coroutine_desc * thrd_cor = kernelTLS.this_thread->curr_cor = kernelTLS.this_coroutine;
+        ThreadCtxSwitch(thrd_cor, proc_cor);
+}
 …
         processor * proc = (processor *) arg;
         kernelTLS.this_processor = proc;
+        kernelTLS.this_coroutine = NULL;
         kernelTLS.this_thread    = NULL;
         kernelTLS.preemption_state.[enabled, disable_count] = [false, 1];
 …
         // to waste the perfectly valid stack create by pthread.
         current_stack_info_t info;
         __stack_t ctx;
         info.storage = &ctx;
+        machine_context_t ctx;
+        info.context = &ctx;
         (proc->runner){ proc, &info };
         __cfaabi_dbg_print_safe("Coroutine : created stack %p\n", get_coroutine(proc->runner)->stack.storage);
+        __cfaabi_dbg_print_safe("Coroutine : created stack %p\n", get_coroutine(proc->runner)->stack.base);
         //Set global state
+        kernelTLS.this_coroutine = get_coroutine(proc->runner);
         kernelTLS.this_thread    = NULL;
 …
 // KERNEL_ONLY
 void kernel_first_resume( processor * this ) {
         thread_desc * src = mainThread;
+void kernel_first_resume(processor * this) {
+        coroutine_desc * src = kernelTLS.this_coroutine;
         coroutine_desc * dst = get_coroutine(this->runner);
         verify( ! kernelTLS.preemption_state.enabled );
         __stack_prepare( &dst->stack, 65000 );
+        create_stack(&dst->stack, dst->stack.size);
         CtxStart(&this->runner, CtxInvokeCoroutine);
         verify( ! kernelTLS.preemption_state.enabled );
         dst->last = &src->self_cor;
         dst->starter = dst->starter ? dst->starter : &src->self_cor;
+        dst->last = src;
+        dst->starter = dst->starter ? dst->starter : src;
         // set state of current coroutine to inactive
         src->state = src->state == Halted ? Halted : Inactive;
+        // set new coroutine that task is executing
+        kernelTLS.this_coroutine = dst;
+        // SKULLDUGGERY normally interrupts are enable before leaving a coroutine ctxswitch.
+        // Therefore, when first creating a coroutine, interrupts are enable before calling the main.
+        // This is consistent with thread creation. However, when creating the main processor coroutine,
+        // we wan't interrupts to be disabled. Therefore, we double-disable interrupts here so they will
+        // stay disabled.
+        disable_interrupts();
         // context switch to specified coroutine
         verify( dst->context.SP );
         CtxSwitch( &src->context, &dst->context );
+        assert( src->stack.context );
+        CtxSwitch( src->stack.context, dst->stack.context );
         // when CtxSwitch returns we are back in the src coroutine
 …
         verify( ! kernelTLS.preemption_state.enabled );
+}
-// KERNEL_ONLY
-void kernel_last_resume( processor * this ) {
-        coroutine_desc * src = &mainThread->self_cor;
-        coroutine_desc * dst = get_coroutine(this->runner);
-        verify( ! kernelTLS.preemption_state.enabled );
-        verify( dst->starter == src );
-        verify( dst->context.SP );
-        // context switch to the processor
-        CtxSwitch( &src->context, &dst->context );
+}
 …
 void ScheduleThread( thread_desc * thrd ) {
         verify( thrd );
         verify( thrd->state != Halted );
+        verify( thrd->self_cor.state != Halted );
         verify( ! kernelTLS.preemption_state.enabled );
 …
         __cfaabi_dbg_print_safe("Kernel : Starting\n");
-        __page_size = sysconf( _SC_PAGESIZE );
         __cfa_dbg_global_clusters.list{ __get };
         __cfa_dbg_global_clusters.lock{};
 …
         mainThread = (thread_desc *)&storage_mainThread;
         current_stack_info_t info;
-        info.storage = (__stack_t*)&storage_mainThreadCtx;
         (*mainThread){ &info };
 …
         kernelTLS.this_processor = mainProcessor;
         kernelTLS.this_thread    = mainThread;
+        kernelTLS.this_coroutine = &mainThread->self_cor;
         // Enable preemption
 …
         // which is currently here
         __atomic_store_n(&mainProcessor->do_terminate, true, __ATOMIC_RELEASE);
         kernel_last_resume( kernelTLS.this_processor );
+        returnToKernel();
         mainThread->self_cor.state = Halted;
 …
                 __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 );
+                if ( get_coroutine(thrd) != kernelTLS.this_coroutine ) {
+                        len = snprintf( abort_text, abort_text_size, " in coroutine %.256s (%p).\n", kernelTLS.this_coroutine->name, kernelTLS.this_coroutine );
                         __cfaabi_dbg_bits_write( abort_text, len );
+                }

libcfa/src/concurrency/thread.cfa

-              r933f32f
+              r6a9d4b4
 // Thread ctors and dtors
 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;
+        verify(&self_cor);
         curr_cor = &self_cor;
         self_mon.owner = &this;
 …
 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 );
+        coroutine_desc* thrd_c = get_coroutine(this);
+        thread_desc   * thrd_h = get_thread   (this);
+        thrd_c->last = TL_GET( this_coroutine );
+        // __cfaabi_dbg_print_safe("Thread start : %p (t %p, c %p)\n", this, thrd_c, thrd_h);
         disable_interrupts();
+        create_stack(&thrd_c->stack, thrd_c->stack.size);
+        kernelTLS.this_coroutine = thrd_c;
         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 );
+        assert( thrd_c->last->stack.context );
+        CtxSwitch( thrd_c->last->stack.context, thrd_c->stack.context );
         ScheduleThread(this_thrd);
+        ScheduleThread(thrd_h);
         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 __finish_creation(void) {
+                coroutine_desc* thrd_c = kernelTLS.this_coroutine;
+                ThreadCtxSwitch( thrd_c, thrd_c->last );
+        }
+}
 …
+}
+// KERNEL ONLY
+void ThreadCtxSwitch(coroutine_desc* src, coroutine_desc* dst) {
+        // set state of current coroutine to inactive
+        src->state = src->state == Halted ? Halted : Inactive;
+        dst->state = Active;
+        // set new coroutine that the processor is executing
+        // and context switch to it
+        kernelTLS.this_coroutine = dst;
+        assert( src->stack.context );
+        CtxSwitch( src->stack.context, dst->stack.context );
+        kernelTLS.this_coroutine = src;
+        // set state of new coroutine to active
+        dst->state = dst->state == Halted ? Halted : Inactive;
+        src->state = Active;
+}
 // Local Variables: //
 // mode: c //

libcfa/src/concurrency/thread.hfa

-              r933f32f
+              r6a9d4b4
 void ^?{}(thread_desc & this);
 static inline void ?{}(thread_desc & this)                                                                  { this{ "Anonymous Thread", *mainCluster, NULL, 65000 }; }
+static inline void ?{}(thread_desc & this)                                                                  { this{ "Anonymous Thread", *mainCluster, NULL, 0 }; }
 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 )                                            { this{ "Anonymous Thread", cl, NULL, 0 }; }
+static inline void ?{}(thread_desc & this, struct cluster & cl, size_t stackSize )                          { this{ "Anonymous Thread", cl, 0, 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)                                         { this{ name, *mainCluster, NULL, 0 }; }
+static inline void ?{}(thread_desc & this, const char * const name, struct cluster & cl )                   { this{ name, cl, NULL, 0 }; }
 static inline void ?{}(thread_desc & this, const char * const name, struct cluster & cl, size_t stackSize ) { this{ name, cl, NULL, stackSize }; }

libcfa/src/containers/maybe.cfa

-              r933f32f
+              r6a9d4b4
 // Created On       : Wed May 24 15:40:00 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sun Feb 17 11:22:03 2019
 // Update Count     : 3
+// Last Modified On : Thu Jul 20 15:23:50 2017
+// Update Count     : 2
 //
 …
 forall(otype T)
 maybe(T) ?=?(maybe(T) & this, maybe(T) that) {
         if (this.has_value && that.has_value) {
+        if (this.has_value & that.has_value) {
                 this.value = that.value;
         } else if (this.has_value) {

libcfa/src/containers/result.cfa

-              r933f32f
+              r6a9d4b4
 // Created On       : Wed May 24 15:40:00 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sun Feb 17 11:24:04 2019
 // Update Count     : 3
+// Last Modified On : Thu Jul 20 15:23:58 2017
+// Update Count     : 2
 //
 …
 forall(otype T, otype E)
 result(T, E) ?=?(result(T, E) & this, result(T, E) that) {
         if (this.has_value && that.has_value) {
+        if (this.has_value & that.has_value) {
                 this.value = that.value;
         } else if (this.has_value) {

libcfa/src/fstream.cfa

-              r933f32f
+              r6a9d4b4
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu May 16 08:33:28 2019
 // Update Count     : 328
+// Last Modified On : Mon Dec 24 18:33:38 2018
+// Update Count     : 304
 //
 …
 #include <complex.h>                                                                    // creal, cimag
 #include <assert.h>
-#include <errno.h>                                                                              // errno
 #define IO_MSG "I/O error: "
 void ?{}( ofstream & os, void * file ) {
+void ?{}( ofstream & os, void * file, bool sepDefault, bool sepOnOff, bool nlOnOff, bool prt, const char * separator, const char * tupleSeparator ) {
         os.file = file;
+        os.sepDefault = true;
+        os.sepOnOff = false;
+        os.nlOnOff = true;
+        os.prt = false;
+        os.sawNL = false;
+        sepSet( os, " " );
+        os.sepDefault = sepDefault;
+        os.sepOnOff = sepOnOff;
+        os.nlOnOff = nlOnOff;
+        os.prt = prt;
+        sepSet( os, separator );
         sepSetCur( os, sepGet( os ) );
         sepSetTuple( os, ", " );
+        sepSetTuple( os, tupleSeparator );
+}
 …
 void open( ofstream & os, const char * name, const char * mode ) {
         FILE * file = fopen( name, mode );
+        FILE *file = fopen( name, mode );
         #ifdef __CFA_DEBUG__
         if ( file == 0 ) {
+                abort( IO_MSG "open output file \"%s\", %s", name, strerror( errno ) );
+                fprintf( stderr, IO_MSG "open output file \"%s\", ", name );
+                perror( 0 );
+                exit( EXIT_FAILURE );
         } // if
         #endif // __CFA_DEBUG__
         (os){ file };
+        (os){ file, true, false, true, false, " ", ", " };
 } // open
 …
         if ( fclose( (FILE *)(os.file) ) == EOF ) {
                 abort( IO_MSG "close output %s", strerror( errno ) );
+                perror( IO_MSG "close output" );
         } // if
 } // close
 …
 ofstream & write( ofstream & os, const char * data, size_t size ) {
         if ( fail( os ) ) {
+                abort( "attempt write I/O on failed stream\n" );
+                fprintf( stderr, "attempt write I/O on failed stream\n" );
+                exit( EXIT_FAILURE );
         } // if
         if ( fwrite( data, 1, size, (FILE *)(os.file) ) != size ) {
+                abort( IO_MSG "write %s", strerror( errno ) );
+                perror( IO_MSG "write" );
+                exit( EXIT_FAILURE );
         } // if
         return os;
 …
         if ( len == EOF ) {
                 if ( ferror( (FILE *)(os.file) ) ) {
+                        abort( "invalid write\n" );
+                        fprintf( stderr, "invalid write\n" );
+                        exit( EXIT_FAILURE );
                 } // if
         } // if
 …
 } // fmt
 static ofstream soutFile = { (FILE *)(&_IO_2_1_stdout_) };
+static ofstream soutFile = { (FILE *)(&_IO_2_1_stdout_), true, false, true, false, " ", ", " };
 ofstream & sout = soutFile;
 static ofstream serrFile = { (FILE *)(&_IO_2_1_stderr_) };
+static ofstream serrFile = { (FILE *)(&_IO_2_1_stderr_), true, false, true, false, " ", ", " };
 ofstream & serr = serrFile;
-// static ofstream sexitFile = { (FILE *)(&_IO_2_1_stdout_) };
-// ofstream & sexit = sexitFile;
-// static ofstream sabortFile = { (FILE *)(&_IO_2_1_stderr_) };
-// ofstream & sabort = sabortFile;
-void nl( ofstream & os ) {
-        if ( getANL( os ) ) (ofstream &)(nl( os ));                     // implementation only
-        else setPrt( os, false );                                                       // turn off
+}
 //---------------------------------------
 …
 void ?{}( ifstream & is, void * file ) {
         is.file = file;
-        is.nlOnOff = false;
+}
 …
         open( is, name, "r" );
+}
-void nlOn( ifstream & os ) { os.nlOnOff = true; }
-void nlOff( ifstream & os ) { os.nlOnOff = false; }
-bool getANL( ifstream & os ) { return os.nlOnOff; }
 int fail( ifstream & is ) {
 …
 void open( ifstream & is, const char * name, const char * mode ) {
         FILE * file = fopen( name, mode );
+        FILE *file = fopen( name, mode );
         #ifdef __CFA_DEBUG__
         if ( file == 0 ) {
+                abort( IO_MSG "open input file \"%s\", %s\n", name, strerror( errno ) );
+                fprintf( stderr, IO_MSG "open input file \"%s\", ", name );
+                perror( 0 );
+                exit( EXIT_FAILURE );
         } // if
         #endif // __CFA_DEBUG__
 …
         if ( fclose( (FILE *)(is.file) ) == EOF ) {
                 abort( IO_MSG "close input %s", strerror( errno ) );
+                perror( IO_MSG "close input" );
         } // if
 } // close
 …
 ifstream & read( ifstream & is, char * data, size_t size ) {
         if ( fail( is ) ) {
+                abort( "attempt read I/O on failed stream\n" );
+                fprintf( stderr, "attempt read I/O on failed stream\n" );
+                exit( EXIT_FAILURE );
         } // if
         if ( fread( data, size, 1, (FILE *)(is.file) ) == 0 ) {
+                abort( IO_MSG "read %s", strerror( errno ) );
+                perror( IO_MSG "read" );
+                exit( EXIT_FAILURE );
         } // if
         return is;
 …
 ifstream &ungetc( ifstream & is, char c ) {
         if ( fail( is ) ) {
+                abort( "attempt ungetc I/O on failed stream\n" );
+                fprintf( stderr, "attempt ungetc I/O on failed stream\n" );
+                exit( EXIT_FAILURE );
         } // if
         if ( ungetc( c, (FILE *)(is.file) ) == EOF ) {
+                abort( IO_MSG "ungetc %s", strerror( errno ) );
+                perror( IO_MSG "ungetc" );
+                exit( EXIT_FAILURE );
         } // if
         return is;
 …
         if ( len == EOF ) {
                 if ( ferror( (FILE *)(is.file) ) ) {
+                        abort( "invalid read\n" );
+                        fprintf( stderr, "invalid read\n" );
+                        exit( EXIT_FAILURE );
                 } // if
         } // if

libcfa/src/fstream.hfa

-              r933f32f
+              r6a9d4b4
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu May 16 08:34:10 2019
 // Update Count     : 157
+// Last Modified On : Mon Dec 24 18:33:41 2018
+// Update Count     : 149
 //
 …
 extern ofstream & sout, & serr;
-// extern ofstream & sout, & serr, & sexit, & sabort;
-// void nl( ofstream & os );
 struct ifstream {
         void * file;
-        bool nlOnOff;
 }; // ifstream
 // public
-void nlOn( ifstream & );
-void nlOff( ifstream & );
-bool getANL( ifstream & );
 int fail( ifstream & is );
 int eof( ifstream & is );

libcfa/src/gmp.hfa

-              r933f32f
+              r6a9d4b4
 // Created On       : Tue Apr 19 08:43:43 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Apr 20 09:01:52 2019
 // Update Count     : 24
+// Last Modified On : Tue Dec  4 23:25:51 2018
+// Update Count     : 22
 //
 …
         void ?|?( ostype & os, Int mp ) {
                 (ostype)(os | mp); nl( os );
+                (ostype)(os | mp); if ( getANL( os ) ) nl( os );
         } // ?|?
 } // distribution

libcfa/src/heap.cfa

-              r933f32f
+              r6a9d4b4
 // Created On       : Tue Dec 19 21:58:35 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu May  9 16:29:12 2019
 // Update Count     : 516
+// Last Modified On : Thu Sep  6 09:01:30 2018
+// Update Count     : 513
 //
 …
                 StackLF<Storage> freeList;
                 #else
                         #error undefined lock type for bucket lock
+                #error undefined lock type for bucket lock
                 #endif // SPINLOCK
                 size_t blockSize;                                                               // size of allocations on this list
 …
 }; // HeapManager
 static inline size_t getKey( const HeapManager.FreeHeader & freeheader ) { return freeheader.blockSize; }
 // statically allocated variables => zero filled.
 static size_t pageSize;                                                                 // architecture pagesize
 static size_t heapExpand;                                                               // sbrk advance
 …
         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
+                           } // HeapManager
 …
         // } // if
         #endif // __STATISTICS__
 } // ~HeapManager
+                                } // ~HeapManager
 …
 static inline void * doMalloc( size_t size ) with ( heapManager ) {
         HeapManager.Storage * block;                                            // pointer to new block of storage
+        HeapManager.Storage * block;
         // Look up size in the size list.  Make sure the user request includes space for the header that must be allocated
 …
         __atomic_add_fetch( &allocFree, -size, __ATOMIC_SEQ_CST );
         if ( traceHeap() ) {
+                enum { BufferSize = 64 };
+                char helpText[BufferSize];
+                char helpText[64];
                 int len = snprintf( helpText, sizeof(helpText), "Free( %p ) size:%zu\n", addr, size );
                 __cfaabi_dbg_bits_write( helpText, len );
 …
                         // 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__
+                                #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
 …
 // Local Variables: //
 // tab-width: 4 //
 // compile-command: "cfa -nodebug -O2 heap.cfa" //
+// compile-command: "cfa -nodebug -O2 heap.c" //
 // End: //

libcfa/src/iostream.cfa

-              r933f32f
+              r6a9d4b4
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sun May 19 10:48:27 2019
 // Update Count     : 654
+// Last Modified On : Mon Dec 24 18:33:40 2018
+// Update Count     : 589
 //
 …
 extern size_t strlen (const char *__s) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
 #include <float.h>                                                                              // DBL_DIG, LDBL_DIG
-#include <math.h>                                                                               // isfinite
 #include <complex.h>                                                                    // creal, cimag
+}
 forall( dtype ostype | ostream( ostype ) ) {
-        ostype & ?|?( ostype & os, zero_t ) {
-                if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
-                fmt( os, "%d", 0n );
-                return os;
-        } // ?|?
-        void ?|?( ostype & os, zero_t z ) {
-                (ostype &)(os | z); nl( os );
-        } // ?|?
-        ostype & ?|?( ostype & os, one_t ) {
-                if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
-                fmt( os, "%d", 1n );
-                return os;
-        } // ?|?
-        void ?|?( ostype & os, one_t o ) {
-                (ostype &)(os | o); nl( os );
-        } // ?|?
         ostype & ?|?( ostype & os, bool b ) {
                 if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
 …
         } // ?|?
-        static void checkDecPt( ostype & os, const char * buf, int len ) {
-                for ( int i = 0;; i += 1 ) {
-                        if ( i == len ) { fmt( os, "." ); break; }
-                        if ( buf[i] == '.' ) break;
-                } // for
-        } // checkDecPt
         ostype & ?|?( ostype & os, float f ) {
                 if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
+                char buf[48];
+                int len = snprintf( buf, 48, "%g", f );
+                fmt( os, "%s", buf );
+                if ( isfinite( f ) ) checkDecPt( os, buf, len ); // always print decimal point
+                fmt( os, "%g", f );
                 return os;
         } // ?|?
 …
         ostype & ?|?( ostype & os, double d ) {
                 if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
+                char buf[48];
+                int len = snprintf( buf, 48, "%.*lg", DBL_DIG, d );
+                fmt( os, "%s", buf );
+                if ( isfinite( d ) ) checkDecPt( os, buf, len ); // always print decimal point
+                fmt( os, "%.*lg", DBL_DIG, d );
                 return os;
         } // ?|?
 …
         ostype & ?|?( ostype & os, long double ld ) {
                 if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
+                char buf[48];
+                int len = snprintf( buf, 48, "%.*Lg", LDBL_DIG, ld );
+                fmt( os, "%s", buf );
+                if ( isfinite( ld ) ) checkDecPt( os, buf, len ); // always print decimal point
+                fmt( os, "%.*Lg", LDBL_DIG, ld );
                 return os;
         } // ?|?
 …
         ostype & ?|?( ostype & os, float _Complex fc ) {
                 if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
+//              os | crealf( fc ) | nonl;
+                float f = crealf( fc );
+                char buf[48];
+                int len = snprintf( buf, 48, "%g", f );
+                fmt( os, "%s", buf );
+                if ( isfinite( f ) ) checkDecPt( os, buf, len ); // always print decimal point
+                f = cimagf( fc );
+                len = snprintf( buf, 48, "%+g", f );
+                fmt( os, "%s", buf );
+                if ( isfinite( f ) ) checkDecPt( os, buf, len ); // always print decimal point
+                fmt( os, "i" );
+                fmt( os, "%g%+gi", crealf( fc ), cimagf( fc ) );
                 return os;
         } // ?|?
 …
         ostype & ?|?( ostype & os, double _Complex dc ) {
                 if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
+//              os | creal( dc ) | nonl;
+                double d = creal( dc );
+                char buf[48];
+                int len = snprintf( buf, 48, "%.*lg", DBL_DIG, d );
+                fmt( os, "%s", buf );
+                if ( isfinite( d ) ) checkDecPt( os, buf, len ); // always print decimal point
+                d = cimag( dc );
+                len = snprintf( buf, 48, "%+.*lg", DBL_DIG, d );
+                fmt( os, "%s", buf );
+                if ( isfinite( d ) ) checkDecPt( os, buf, len ); // always print decimal point
+                fmt( os, "i" );
+                fmt( os, "%.*lg%+.*lgi", DBL_DIG, creal( dc ), DBL_DIG, cimag( dc ) );
                 return os;
         } // ?|?
 …
         ostype & ?|?( ostype & os, long double _Complex ldc ) {
                 if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
+//              os | creall( ldc ) || nonl;
+                long double ld = creall( ldc );
+                char buf[48];
+                int len = snprintf( buf, 48, "%.*Lg", LDBL_DIG, ld );
+                fmt( os, "%s", buf );
+                if ( isfinite( ld ) ) checkDecPt( os, buf, len ); // always print decimal point
+                ld = cimagl( ldc );
+                len = snprintf( buf, 48, "%+.*Lg", LDBL_DIG, ld );
+                fmt( os, "%s", buf );
+                if ( isfinite( ld ) ) checkDecPt( os, buf, len ); // always print decimal point
+                fmt( os, "i" );
+                fmt( os, "%.*Lg%+.*Lgi", LDBL_DIG, creall( ldc ), LDBL_DIG, cimagl( ldc ) );
                 return os;
         } // ?|?
 …
         istype & ?|?( istype & is, char & c ) {
+                char temp;
+                for () {
+                        fmt( is, "%c", &temp );                                                 // must pass pointer through varg to fmt
+                        // do not overwrite parameter with newline unless appropriate
+                        if ( temp != '\n' || getANL( is ) ) { c = temp; break; }
+                        if ( eof( is ) ) break;
+                } // for
+                fmt( is, "%c", &c );                                                    // must pass pointer through varg to fmt
                 return is;
         } // ?|?
 …
         } // ?|?
         // manipulators
         istype & ?|?( istype & is, istype & (* manip)( istype & ) ) {
 …
         istype & nl( istype & is ) {
                 fmt( is, "%*[^\n]" );                                                   // ignore characters to newline
+                fmt( is, "%*[ \t\f\n\r\v]" );                                   // ignore whitespace
                 return is;
         } // nl
-        istype & nlOn( istype & is ) {
-                nlOn( is );                                                                             // call void returning
-                return is;
-        } // nlOn
-        istype & nlOff( istype & is ) {
-                nlOff( is );                                                                    // call void returning
-                return is;
-        } // nlOff
 } // distribution

libcfa/src/iostream.hfa

-              r933f32f
+              r6a9d4b4
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat May 11 10:31:27 2019
 // Update Count     : 232
+// Last Modified On : Mon Dec 24 18:33:40 2018
+// Update Count     : 220
 //
 …
         void close( ostype & os );
         ostype & write( ostype &, const char *, size_t );
         int fmt( ostype &, const char format[], ... ) __attribute__(( format(printf, 2, 3) ));
+        int fmt( ostype &, const char format[], ... );
 }; // ostream
 …
 forall( dtype ostype | ostream( ostype ) ) {
-        ostype & ?|?( ostype &, zero_t );
-        void ?|?( ostype &, zero_t );
-        ostype & ?|?( ostype &, one_t );
-        void ?|?( ostype &, one_t );
         ostype & ?|?( ostype &, bool );
         void ?|?( ostype &, bool );
 …
 trait istream( dtype istype ) {
-        void nlOn( istype & );                                                          // read newline
-        void nlOff( istype & );                                                         // scan newline
-        bool getANL( istype & );                                                        // get scan newline (on/off)
         int fail( istype & );
         int eof( istype & );
 …
         istype & read( istype &, char *, size_t );
         istype & ungetc( istype &, char );
         int fmt( istype &, const char format[], ... ) __attribute__(( format(scanf, 2, 3) ));
+        int fmt( istype &, const char format[], ... );
 }; // istream
 …
         istype & ?|?( istype &, istype & (*)( istype & ) );
         istype & nl( istype & is );
-        istype & nlOn( istype & );
-        istype & nlOff( istype & );
 } // distribution
 …
 // Local Variables: //
+// mode: c //
 // tab-width: 4 //
 // End: //

libcfa/src/rational.cfa

-              r933f32f
+              r6a9d4b4
 // Created On       : Wed Apr  6 17:54:28 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Mar 28 17:33:03 2019
 // Update Count     : 181
+// Last Modified On : Sun Dec 23 22:56:49 2018
+// Update Count     : 170
 //
 …
         static RationalImpl simplify( RationalImpl & n, RationalImpl & d ) {
                 if ( d == (RationalImpl){0} ) {
+                        abort( "Invalid rational number construction: denominator cannot be equal to 0.\n" );
+                        serr | "Invalid rational number construction: denominator cannot be equal to 0.";
+                        exit( EXIT_FAILURE );
                 } // exit
                 if ( d < (RationalImpl){0} ) { d = -d; n = -n; } // move sign to numerator
 …
         void ?{}( Rational(RationalImpl) & r, RationalImpl n, RationalImpl d ) {
                 RationalImpl t = simplify( n, d );                              // simplify
+                r.[numerator, denominator] = [n / t, d / t];
+                r.numerator = n / t;
+                r.denominator = d / t;
         } // rational
 …
                 RationalImpl prev = r.numerator;
                 RationalImpl t = gcd( abs( n ), r.denominator ); // simplify
+                r.[numerator, denominator] = [n / t, r.denominator / t];
+                r.numerator = n / t;
+                r.denominator = r.denominator / t;
                 return prev;
         } // numerator
 …
                 RationalImpl prev = r.denominator;
                 RationalImpl t = simplify( r.numerator, d );    // simplify
+                r.[numerator, denominator] = [r.numerator / t, d / t];
+                r.numerator = r.numerator / t;
+                r.denominator = d / t;
                 return prev;
         } // denominator
 …
         Rational(RationalImpl) +?( Rational(RationalImpl) r ) {
+                return (Rational(RationalImpl)){ r.numerator, r.denominator };
+                Rational(RationalImpl) t = { r.numerator, r.denominator };
+                return t;
         } // +?
         Rational(RationalImpl) -?( Rational(RationalImpl) r ) {
+                return (Rational(RationalImpl)){ -r.numerator, r.denominator };
+                Rational(RationalImpl) t = { -r.numerator, r.denominator };
+                return t;
         } // -?
         Rational(RationalImpl) ?+?( Rational(RationalImpl) l, Rational(RationalImpl) r ) {
                 if ( l.denominator == r.denominator ) {                 // special case
+                        return (Rational(RationalImpl)){ l.numerator + r.numerator, l.denominator };
+                        Rational(RationalImpl) t = { l.numerator + r.numerator, l.denominator };
+                        return t;
                 } else {
+                        return (Rational(RationalImpl)){ l.numerator * r.denominator + l.denominator * r.numerator, l.denominator * r.denominator };
+                        Rational(RationalImpl) t = { l.numerator * r.denominator + l.denominator * r.numerator, l.denominator * r.denominator };
+                        return t;
                 } // if
         } // ?+?
 …
         Rational(RationalImpl) ?-?( Rational(RationalImpl) l, Rational(RationalImpl) r ) {
                 if ( l.denominator == r.denominator ) {                 // special case
+                        return (Rational(RationalImpl)){ l.numerator - r.numerator, l.denominator };
+                        Rational(RationalImpl) t = { l.numerator - r.numerator, l.denominator };
+                        return t;
                 } else {
+                        return (Rational(RationalImpl)){ l.numerator * r.denominator - l.denominator * r.numerator, l.denominator * r.denominator };
+                        Rational(RationalImpl) t = { l.numerator * r.denominator - l.denominator * r.numerator, l.denominator * r.denominator };
+                        return t;
                 } // if
         } // ?-?
         Rational(RationalImpl) ?*?( Rational(RationalImpl) l, Rational(RationalImpl) r ) {
+                return (Rational(RationalImpl)){ l.numerator * r.numerator, l.denominator * r.denominator };
+                Rational(RationalImpl) t = { l.numerator * r.numerator, l.denominator * r.denominator };
+                return t;
         } // ?*?
         Rational(RationalImpl) ?/?( Rational(RationalImpl) l, Rational(RationalImpl) r ) {
                 if ( r.numerator < (RationalImpl){0} ) {
+                        r.[numerator, denominator] = [-r.numerator, -r.denominator];
+                        r.numerator = -r.numerator;
+                        r.denominator = -r.denominator;
                 } // if
+                return (Rational(RationalImpl)){ l.numerator * r.denominator, l.denominator * r.numerator };
+                Rational(RationalImpl) t = { l.numerator * r.denominator, l.denominator * r.numerator };
+                return t;
         } // ?/?
 …
         forall( dtype istype | istream( istype ) | { istype & ?|?( istype &, RationalImpl & ); } )
         istype & ?|?( istype & is, Rational(RationalImpl) & r ) {
+                RationalImpl t;
                 is | r.numerator | r.denominator;
                 RationalImpl t = simplify( r.numerator, r.denominator );
+                t = simplify( r.numerator, r.denominator );
                 r.numerator /= t;
                 r.denominator /= t;
 …
         } // distribution
 } // distribution
-forall( otype RationalImpl | arithmetic( RationalImpl ) | { RationalImpl ?\?( RationalImpl, unsigned long ); } )
-Rational(RationalImpl) ?\?( Rational(RationalImpl) x, long int y ) {
-        if ( y < 0 ) {
-                return (Rational(RationalImpl)){ x.denominator \ -y, x.numerator \ -y };
-        } else {
-                return (Rational(RationalImpl)){ x.numerator \ y, x.denominator \ y };
-        } // if
+}
 // conversion

libcfa/src/rational.hfa

-              r933f32f
+              r6a9d4b4
 // Created On       : Wed Apr  6 17:56:25 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Tue Mar 26 23:16:10 2019
 // Update Count     : 109
+// Last Modified On : Tue Dec  4 23:07:46 2018
+// Update Count     : 106
 //
 …
 } // distribution
-forall( otype RationalImpl | arithmetic( RationalImpl ) |{RationalImpl ?\?( RationalImpl, unsigned long );} )
-Rational(RationalImpl) ?\?( Rational(RationalImpl) x, long int y );
 // conversion
 forall( otype RationalImpl | arithmetic( RationalImpl ) | { double convert( RationalImpl ); } )

libcfa/src/stdhdr/stdbool.h

-              r933f32f
+              r6a9d4b4
 // Created On       : Mon Jul  4 23:25:26 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Mon Mar 25 08:00:08 2019
 // Update Count     : 15
+// Last Modified On : Tue Jul  5 20:39:51 2016
+// Update Count     : 12
 //
 extern "C" {
 #include_next <stdbool.h>                                                               // has internal check for multiple expansion
-// allows printing as true/false
-#if defined( true )
-#undef true
-#define true ((_Bool)1)
-#endif // true
-#if defined( false )
-#undef false
-#define false ((_Bool)0)
-#endif // false
 } // extern "C"

libcfa/src/stdlib.hfa

-              r933f32f
+              r6a9d4b4
 // Created On       : Thu Jan 28 17:12:35 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed Apr 24 17:35:43 2019
 // Update Count     : 352
+// Last Modified On : Mon Dec 17 15:37:45 2018
+// Update Count     : 346
 //
 …
         } // malloc
+        // T & malloc( void ) {
+        //      int & p = *(T *)(void *)malloc( (size_t)sizeof(T) ); // C malloc
+        //      printf( "& malloc %p\n", &p );
+        //      return p;
+        //      //      return (T &)*(T *)(void *)malloc( (size_t)sizeof(T) ); // C malloc
+        // } // malloc
         T * calloc( size_t dim ) {
                 return (T *)(void *)calloc( dim, sizeof(T) );   // C calloc
 …
         T * alloc( char fill ) {
                 T * ptr = (T *)(void *)malloc( (size_t)sizeof(T) );     // C malloc
                 return (T *)memset( ptr, (int)fill, sizeof(T) ); // initialize with fill value
+                return (T *)memset( ptr, (int)fill, sizeof(T) );        // initial with fill value
         } // alloc
 …
         T * alloc( size_t dim, char fill ) {
                 T * ptr = (T *)(void *)malloc( dim * (size_t)sizeof(T) ); // C calloc
                 return (T *)memset( ptr, (int)fill, dim * sizeof(T) ); // initialize with fill value
+                T * ptr = (T *)(void *)malloc( dim * (size_t)sizeof(T) ); // C malloc
+                return (T *)memset( ptr, (int)fill, dim * sizeof(T) );    // initial with fill value
         } // alloc

libcfa/src/time.hfa

-              r933f32f
+              r6a9d4b4
 static inline {
         Duration ?=?( Duration & dur, __attribute__((unused)) zero_t ) { return dur{ 0 }; }
+        Duration ?=?( Duration & dur, zero_t ) { return dur{ 0 }; }
         Duration +?( Duration rhs ) with( rhs ) {       return (Duration)@{ +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; }
+        bool ?==?( Duration lhs, zero_t ) { return lhs.tv == 0; }
+        bool ?!=?( Duration lhs, zero_t ) { return lhs.tv != 0; }
+        bool ?<? ( Duration lhs, zero_t ) { return lhs.tv <  0; }
+        bool ?<=?( Duration lhs, zero_t ) { return lhs.tv <= 0; }
+        bool ?>? ( Duration lhs, zero_t ) { return lhs.tv >  0; }
+        bool ?>=?( Duration lhs, zero_t ) { return lhs.tv >= 0; }
         Duration abs( Duration rhs ) { return rhs.tv >= 0 ? rhs : -rhs; }
 …
         void ?{}( timeval & t, time_t sec, suseconds_t usec ) { t.tv_sec = sec; t.tv_usec = usec; }
         void ?{}( timeval & t, time_t sec ) { t{ sec, 0 }; }
         void ?{}( timeval & t, __attribute__((unused)) zero_t ) { t{ 0, 0 }; }
         timeval ?=?( timeval & t, __attribute__((unused)) zero_t ) { return t{ 0 }; }
+        void ?{}( timeval & t, zero_t ) { t{ 0, 0 }; }
+        timeval ?=?( timeval & t, zero_t ) { return t{ 0 }; }
         timeval ?+?( timeval lhs, timeval rhs ) { return (timeval)@{ lhs.tv_sec + rhs.tv_sec, lhs.tv_usec + rhs.tv_usec }; }
         timeval ?-?( timeval lhs, timeval rhs ) { return (timeval)@{ lhs.tv_sec - rhs.tv_sec, lhs.tv_usec - rhs.tv_usec }; }
 …
         void ?{}( timespec & t, time_t sec, __syscall_slong_t nsec ) { t.tv_sec = sec; t.tv_nsec = nsec; }
         void ?{}( timespec & t, time_t sec ) { t{ sec, 0}; }
         void ?{}( timespec & t, __attribute__((unused)) zero_t ) { t{ 0, 0 }; }
         timespec ?=?( timespec & t, __attribute__((unused)) zero_t ) { return t{ 0 }; }
+        void ?{}( timespec & t, zero_t ) { t{ 0, 0 }; }
+        timespec ?=?( timespec & t, zero_t ) { return t{ 0 }; }
         timespec ?+?( timespec lhs, timespec rhs ) { return (timespec)@{ lhs.tv_sec + rhs.tv_sec, lhs.tv_nsec + rhs.tv_nsec }; }
         timespec ?-?( timespec lhs, timespec rhs ) { return (timespec)@{ lhs.tv_sec - rhs.tv_sec, lhs.tv_nsec - rhs.tv_nsec }; }
 …
 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 }; }
+        Time ?=?( Time & time, zero_t ) { return time{ 0 }; }
         void ?{}( Time & time, timeval t ) with( time ) { tv = (int64_t)t.tv_sec * TIMEGRAN + t.tv_usec * 1000; }

libcfa/src/time_t.hfa

-              r933f32f
+              r6a9d4b4
 static inline void ?{}( Duration & dur ) with( dur ) { tv = 0; }
 static inline void ?{}( Duration & dur, __attribute__((unused)) zero_t ) with( dur ) { tv = 0; }
+static inline void ?{}( Duration & dur, zero_t ) with( dur ) { tv = 0; }
 …
 static inline void ?{}( Time & time ) with( time ) { tv = 0; }
 static inline void ?{}( Time & time, __attribute__((unused)) zero_t ) with( time ) { tv = 0; }
+static inline void ?{}( Time & time, zero_t ) with( time ) { tv = 0; }
 // Local Variables: //

src/CodeGen/CodeGenerator.cc

-              r933f32f
+              r6a9d4b4
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Andrew Beach
 // Last Modified On : Thr May  2 10:47:00 2019
 // Update Count     : 497
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Sat May  5 09:08:32 2018
+// Update Count     : 494
 //
 #include "CodeGenerator.h"
 …
         void CodeGenerator::updateLocation( CodeLocation const & to ) {
                 // skip if linemarks shouldn't appear or if codelocation is unset
                 if ( !options.lineMarks || to.isUnset() ) return;
+                if ( !lineMarks || to.isUnset() ) return;
                 if ( currentLocation.followedBy( to, 0 ) ) {
 …
+        }
+        CodeGenerator::CodeGenerator( std::ostream & os, bool pretty, bool genC, bool lineMarks, bool printExprTypes ) : indent( CodeGenerator::tabsize ), output( os ), printLabels( *this ), options( pretty, genC, lineMarks, printExprTypes ), endl( *this ) {}
+        CodeGenerator::CodeGenerator( std::ostream & os, const Options &options ) : indent( CodeGenerator::tabsize ), output( os ), printLabels( *this ), options(options), endl( *this ) {}
+        CodeGenerator::CodeGenerator( std::ostream & os, bool pretty, bool genC, bool lineMarks, bool printExprTypes ) : indent( CodeGenerator::tabsize ), output( os ), printLabels( *this ), pretty( pretty ), genC( genC ), lineMarks( lineMarks ), printExprTypes( printExprTypes ), endl( *this ) {}
         string CodeGenerator::mangleName( DeclarationWithType * decl ) {
                 // GCC builtins should always be printed unmangled
                 if ( options.pretty || decl->linkage.is_gcc_builtin ) return decl->name;
+                if ( pretty || decl->linkage.is_gcc_builtin ) return decl->name;
                 if ( decl->mangleName != "" ) {
                         // need to incorporate scope level in order to differentiate names for destructors
 …
                 previsit( (BaseSyntaxNode *)node );
                 GuardAction( [this, node](){
                         if ( options.printExprTypes && node->result ) {
                                 output << " /* " << genType( node->result, "", options ) << " */ ";
+                        if ( printExprTypes && node->result ) {
+                                output << " /* " << genType( node->result, "", pretty, genC ) << " */ ";
+                        }
                 } );
 …
         void CodeGenerator::postvisit( FunctionDecl * functionDecl ) {
                 // deleted decls should never be used, so don't print them
                 if ( functionDecl->isDeleted && options.genC ) return;
+                if ( functionDecl->isDeleted && genC ) return;
                 extension( functionDecl );
                 genAttributes( functionDecl->get_attributes() );
 …
                 functionDecl->get_funcSpec().print( output );
+                Options subOptions = options;
+                subOptions.anonymousUnused = functionDecl->has_body();
+                output << genType( functionDecl->get_functionType(), mangleName( functionDecl ), subOptions );
+                output << genType( functionDecl->get_functionType(), mangleName( functionDecl ), pretty, genC );
                 asmName( functionDecl );
 …
         void CodeGenerator::postvisit( ObjectDecl * objectDecl ) {
                 // deleted decls should never be used, so don't print them
                 if ( objectDecl->isDeleted && options.genC ) return;
                 if (objectDecl->get_name().empty() && options.genC ) {
+                if ( objectDecl->isDeleted && genC ) return;
+                if (objectDecl->get_name().empty() && 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" ) );
+            }
+                }
 …
                 handleStorageClass( objectDecl );
                 output << genType( objectDecl->get_type(), mangleName( objectDecl ), options.pretty, options.genC );
+                output << genType( objectDecl->get_type(), mangleName( objectDecl ), pretty, genC );
                 asmName( objectDecl );
 …
         void CodeGenerator::handleAggregate( AggregateDecl * aggDecl, const std::string & kind ) {
                 if( ! aggDecl->parameters.empty() && ! options.genC ) {
+                if( ! aggDecl->parameters.empty() && ! genC ) {
                         // assertf( ! genC, "Aggregate type parameters should not reach code generation." );
                         output << "forall(";
 …
         void CodeGenerator::postvisit( TraitDecl * traitDecl ) {
                 assertf( ! options.genC, "TraitDecls should not reach code generation." );
+                assertf( ! genC, "TraitDecls should not reach code generation." );
                 extension( traitDecl );
                 handleAggregate( traitDecl, "trait " );
 …
         void CodeGenerator::postvisit( TypedefDecl * typeDecl ) {
                 assertf( ! options.genC, "Typedefs are removed and substituted in earlier passes." );
+                assertf( ! genC, "Typedefs are removed and substituted in earlier passes." );
                 output << "typedef ";
                 output << genType( typeDecl->get_base(), typeDecl->get_name(), options ) << endl;
+                output << genType( typeDecl->get_base(), typeDecl->get_name(), pretty, genC ) << endl;
+        }
         void CodeGenerator::postvisit( TypeDecl * typeDecl ) {
                 assertf( ! options.genC, "TypeDecls should not reach code generation." );
+                assertf( ! genC, "TypeDecls should not reach code generation." );
                 output << typeDecl->genTypeString() << " " << typeDecl->name;
                 if ( typeDecl->sized ) {
 …
         void CodeGenerator::postvisit( ConstructorInit * init ){
                 assertf( ! options.genC, "ConstructorInit nodes should not reach code generation." );
+                assertf( ! genC, "ConstructorInit nodes should not reach code generation." );
                 // pseudo-output for constructor/destructor pairs
                 output << "<ctorinit>{" << endl << ++indent << "ctor: ";
 …
                                         } else {
                                                 // no constructors with 0 or more than 2 parameters
                                                 assertf( ! options.genC, "UntypedExpr constructor/destructor with 0 or more than 2 parameters." );
+                                                assertf( ! genC, "UntypedExpr constructor/destructor with 0 or more than 2 parameters." );
                                                 output << "(";
                                                 (*arg++)->accept( *visitor );
 …
                         // an lvalue cast, this has been taken out.
                         output << "(";
                         output << genType( castExpr->get_result(), "", options );
+                        output << genType( castExpr->get_result(), "", pretty, genC );
                         output << ")";
                 } // if
 …
         void CodeGenerator::postvisit( KeywordCastExpr * castExpr ) {
                 assertf( ! options.genC, "KeywordCast should not reach code generation." );
+                assertf( ! genC, "KeywordCast should not reach code generation." );
                 extension( castExpr );
                 output << "((" << castExpr->targetString() << " &)";
 …
         void CodeGenerator::postvisit( VirtualCastExpr * castExpr ) {
                 assertf( ! options.genC, "VirtualCastExpr should not reach code generation." );
+                assertf( ! genC, "VirtualCastExpr should not reach code generation." );
                 extension( castExpr );
                 output << "(virtual ";
 …
         void CodeGenerator::postvisit( UntypedMemberExpr * memberExpr ) {
                 assertf( ! options.genC, "UntypedMemberExpr should not reach code generation." );
+                assertf( ! genC, "UntypedMemberExpr should not reach code generation." );
                 extension( memberExpr );
                 memberExpr->get_aggregate()->accept( *visitor );
 …
                 output << "sizeof(";
                 if ( sizeofExpr->get_isType() ) {
                         output << genType( sizeofExpr->get_type(), "", options );
+                        output << genType( sizeofExpr->get_type(), "", pretty, genC );
                 } else {
                         sizeofExpr->get_expr()->accept( *visitor );
 …
                 output << "__alignof__(";
                 if ( alignofExpr->get_isType() ) {
                         output << genType( alignofExpr->get_type(), "", options );
+                        output << genType( alignofExpr->get_type(), "", pretty, genC );
                 } else {
                         alignofExpr->get_expr()->accept( *visitor );
 …
         void CodeGenerator::postvisit( UntypedOffsetofExpr * offsetofExpr ) {
                 assertf( ! options.genC, "UntypedOffsetofExpr should not reach code generation." );
+                assertf( ! genC, "UntypedOffsetofExpr should not reach code generation." );
                 output << "offsetof(";
                 output << genType( offsetofExpr->get_type(), "", options );
+                output << genType( offsetofExpr->get_type(), "", pretty, genC );
                 output << ", " << offsetofExpr->get_member();
                 output << ")";
 …
                 // use GCC builtin
                 output << "__builtin_offsetof(";
                 output << genType( offsetofExpr->get_type(), "", options );
+                output << genType( offsetofExpr->get_type(), "", pretty, genC );
                 output << ", " << mangleName( offsetofExpr->get_member() );
                 output << ")";
 …
         void CodeGenerator::postvisit( OffsetPackExpr * offsetPackExpr ) {
                 assertf( ! options.genC, "OffsetPackExpr should not reach code generation." );
                 output << "__CFA_offsetpack(" << genType( offsetPackExpr->get_type(), "", options ) << ")";
+                assertf( ! genC, "OffsetPackExpr should not reach code generation." );
+                output << "__CFA_offsetpack(" << genType( offsetPackExpr->get_type(), "", pretty, genC ) << ")";
+        }
 …
                 extension( commaExpr );
                 output << "(";
                 if ( options.genC ) {
+                if ( genC ) {
                         // arg1 of a CommaExpr is never used, so it can be safely cast to void to reduce gcc warnings.
                         commaExpr->set_arg1( new CastExpr( commaExpr->get_arg1() ) );
 …
         void CodeGenerator::postvisit( TupleAssignExpr * tupleExpr ) {
                 assertf( ! options.genC, "TupleAssignExpr should not reach code generation." );
+                assertf( ! genC, "TupleAssignExpr should not reach code generation." );
                 tupleExpr->stmtExpr->accept( *visitor );
+        }
         void CodeGenerator::postvisit( UntypedTupleExpr * tupleExpr ) {
                 assertf( ! options.genC, "UntypedTupleExpr should not reach code generation." );
+                assertf( ! genC, "UntypedTupleExpr should not reach code generation." );
                 extension( tupleExpr );
                 output << "[";
 …
         void CodeGenerator::postvisit( TupleExpr * tupleExpr ) {
                 assertf( ! options.genC, "TupleExpr should not reach code generation." );
+                assertf( ! genC, "TupleExpr should not reach code generation." );
                 extension( tupleExpr );
                 output << "[";
 …
         void CodeGenerator::postvisit( TupleIndexExpr * tupleExpr ) {
                 assertf( ! options.genC, "TupleIndexExpr should not reach code generation." );
+                assertf( ! genC, "TupleIndexExpr should not reach code generation." );
                 extension( tupleExpr );
                 tupleExpr->get_tuple()->accept( *visitor );
 …
         void CodeGenerator::postvisit( TypeExpr * typeExpr ) {
                 // if ( options.genC ) std::cerr << "typeexpr still exists: " << typeExpr << std::endl;
                 // assertf( ! options.genC, "TypeExpr should not reach code generation." );
                 if ( ! options.genC ) {
                         output << genType( typeExpr->get_type(), "", options );
+                // if ( genC ) std::cerr << "typeexpr still exists: " << typeExpr << std::endl;
+                // assertf( ! genC, "TypeExpr should not reach code generation." );
+                if ( ! genC ) {
+                        output<< genType( typeExpr->get_type(), "", pretty, genC );
+                }
+        }
 …
         void CodeGenerator::postvisit( CompoundLiteralExpr *compLitExpr ) {
                 assert( compLitExpr->get_result() && dynamic_cast< ListInit * > ( compLitExpr->get_initializer() ) );
                 output << "(" << genType( compLitExpr->get_result(), "", options ) << ")";
+                output << "(" << genType( compLitExpr->get_result(), "", pretty, genC ) << ")";
                 compLitExpr->get_initializer()->accept( *visitor );
+        }
         void CodeGenerator::postvisit( UniqueExpr * unqExpr ) {
                 assertf( ! options.genC, "Unique expressions should not reach code generation." );
+                assertf( ! genC, "Unique expressions should not reach code generation." );
                 output << "unq<" << unqExpr->get_id() << ">{ ";
                 unqExpr->get_expr()->accept( *visitor );
 …
         void CodeGenerator::postvisit( ConstructorExpr * expr ) {
                 assertf( ! options.genC, "Unique expressions should not reach code generation." );
+                assertf( ! genC, "Unique expressions should not reach code generation." );
                 expr->callExpr->accept( *visitor );
+        }
         void CodeGenerator::postvisit( DeletedExpr * expr ) {
                 assertf( ! options.genC, "Deleted expressions should not reach code generation." );
+                assertf( ! genC, "Deleted expressions should not reach code generation." );
                 expr->expr->accept( *visitor );
+        }
         void CodeGenerator::postvisit( DefaultArgExpr * arg ) {
                 assertf( ! options.genC, "Default argument expressions should not reach code generation." );
+                assertf( ! genC, "Default argument expressions should not reach code generation." );
                 arg->expr->accept( *visitor );
+        }
         void CodeGenerator::postvisit( GenericExpr * expr ) {
                 assertf( ! options.genC, "C11 _Generic expressions should not reach code generation." );
+                assertf( ! genC, "C11 _Generic expressions should not reach code generation." );
                 output << "_Generic(";
                 expr->control->accept( *visitor );
 …
                                 output << "default: ";
                         } else {
                                 output << genType( assoc.type, "", options ) << ": ";
+                                output << genType( assoc.type, "", pretty, genC ) << ": ";
+                        }
                         assoc.expr->accept( *visitor );
 …
         void CodeGenerator::postvisit( ExprStmt * exprStmt ) {
                 assert( exprStmt );
                 if ( options.genC ) {
+                if ( genC ) {
                         // cast the top-level expression to void to reduce gcc warnings.
                         exprStmt->set_expr( new CastExpr( exprStmt->get_expr() ) );
 …
                   case BranchStmt::FallThrough:
                   case BranchStmt::FallThroughDefault:
                         assertf( ! options.genC, "fallthru should not reach code generation." );
+                        assertf( ! genC, "fallthru should not reach code generation." );
                   output << "fallthru";
                         break;
                 } // switch
                 // print branch target for labelled break/continue/fallthru in debug mode
                 if ( ! options.genC && branchStmt->get_type() != BranchStmt::Goto ) {
+                if ( ! genC && branchStmt->get_type() != BranchStmt::Goto ) {
                         if ( ! branchStmt->get_target().empty() ) {
                                 output << " " << branchStmt->get_target();
 …
         void CodeGenerator::postvisit( ThrowStmt * throwStmt ) {
                 assertf( ! options.genC, "Throw statements should not reach code generation." );
+                assertf( ! genC, "Throw statements should not reach code generation." );
                 output << ((throwStmt->get_kind() == ThrowStmt::Terminate) ?
 …
+        }
         void CodeGenerator::postvisit( CatchStmt * stmt ) {
                 assertf( ! options.genC, "Catch statements should not reach code generation." );
+                assertf( ! genC, "Catch statements should not reach code generation." );
                 output << ((stmt->get_kind() == CatchStmt::Terminate) ?
 …
         void CodeGenerator::postvisit( WaitForStmt * stmt ) {
                 assertf( ! options.genC, "Waitfor statements should not reach code generation." );
+                assertf( ! genC, "Waitfor statements should not reach code generation." );
                 bool first = true;
 …
         void CodeGenerator::postvisit( WithStmt * with ) {
                 if ( ! options.genC ) {
+                if ( ! genC ) {
                         output << "with ( ";
                         genCommaList( with->exprs.begin(), with->exprs.end() );
 …
         void CodeGenerator::postvisit( ImplicitCtorDtorStmt * stmt ) {
                 assertf( ! options.genC, "ImplicitCtorDtorStmts should not reach code generation." );
+                assertf( ! genC, "ImplicitCtorDtorStmts should not reach code generation." );
                 stmt->callStmt->accept( *visitor );
+        }

src/CodeGen/CodeGenerator.h

-              r933f32f
+              r6a9d4b4
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Andrew Beach
 // Last Modified On : Tue Apr 30 12:01:00 2019
 // Update Count     : 57
+// Last Modified On : Fri Aug 18 15:40:00 2017
+// Update Count     : 56
 //
 …
 #include <string>                 // for string
-#include "CodeGen/Options.h"      // for Options
 #include "Common/Indenter.h"      // for Indenter
 #include "Common/PassVisitor.h"   // for PassVisitor
 …
                 CodeGenerator( std::ostream &os, bool pretty = false, bool genC = false, bool lineMarks = false, bool printExprTypes = false );
-                CodeGenerator( std::ostream &os, const Options &options );
                 //*** Turn off visit_children for all nodes
 …
                 std::ostream & output;
                 LabelPrinter printLabels;
+                Options options;
+                bool pretty = false;  // pretty print
+                bool genC = false;    // true if output has to be C code
+                bool lineMarks = false;
+                bool printExprTypes = false;
         public:
                 LineEnder endl;

src/CodeGen/GenType.cc

-              r933f32f
+              r6a9d4b4
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Andrew Beach
 // Last Modified On : Wed May  1 15:24:00 2019
 // Update Count     : 23
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Fri Mar 17 09:02:28 2017
+// Update Count     : 22
 //
 #include "GenType.h"
 …
         struct GenType : public WithVisitorRef<GenType>, public WithShortCircuiting {
                 std::string typeString;
                 GenType( const std::string &typeString, const Options &options );
+                GenType( const std::string &typeString, bool pretty, bool genC, bool lineMarks );
                 void previsit( BaseSyntaxNode * );
 …
                 void genArray( const Type::Qualifiers &qualifiers, Type *base, Expression *dimension, bool isVarLen, bool isStatic );
+                Options options;
+                bool pretty = false;    // pretty print
+                bool genC = false;      // generating C code?
+                bool lineMarks = false; // lineMarks on for CodeGenerator?
         };
         std::string genType( Type *type, const std::string &baseString, const Options &options ) {
                 PassVisitor<GenType> gt( baseString, options );
+        std::string genType( Type *type, const std::string &baseString, bool pretty, bool genC , bool lineMarks ) {
+                PassVisitor<GenType> gt( baseString, pretty, genC, lineMarks );
                 std::ostringstream os;
                 if ( ! type->get_attributes().empty() ) {
                         PassVisitor<CodeGenerator> cg( os, options );
+                        PassVisitor<CodeGenerator> cg( os, pretty, genC, lineMarks );
                         cg.pass.genAttributes( type->get_attributes() );
                 } // if
 …
+        }
+        std::string genType( Type *type, const std::string &baseString, bool pretty, bool genC , bool lineMarks ) {
+                return genType( type, baseString, Options(pretty, genC, lineMarks, false ) );
+        }
+        std::string genPrettyType( Type * type, const std::string & baseString ) {
+                return genType( type, baseString, true, false );
+        }
+        GenType::GenType( const std::string &typeString, const Options &options ) : typeString( typeString ), options( options ) {}
+  std::string genPrettyType( Type * type, const std::string & baseString ) {
+        return genType( type, baseString, true, false );
+  }
+        GenType::GenType( const std::string &typeString, bool pretty, bool genC, bool lineMarks ) : typeString( typeString ), pretty( pretty ), genC( genC ), lineMarks( lineMarks ) {}
         // *** BaseSyntaxNode
 …
                 } // if
                 if ( dimension != 0 ) {
                         PassVisitor<CodeGenerator> cg( os, options );
+                        PassVisitor<CodeGenerator> cg( os, pretty, genC, lineMarks );
                         dimension->accept( cg );
                 } else if ( isVarLen ) {
 …
         void GenType::postvisit( ReferenceType * refType ) {
                 assert( refType->base != 0);
                 assertf( ! options.genC, "Reference types should not reach code generation." );
+                assertf( ! genC, "Reference types should not reach code generation." );
                 handleQualifiers( refType );
                 typeString = "&" + typeString;
 …
                         } // if
                 } else {
                         PassVisitor<CodeGenerator> cg( os, options );
+                        PassVisitor<CodeGenerator> cg( os, pretty, genC, lineMarks );
                         os << "(" ;
 …
                 // add forall
                 if( ! funcType->forall.empty() && ! options.genC ) {
+                if( ! funcType->forall.empty() && ! genC ) {
                         // assertf( ! genC, "Aggregate type parameters should not reach code generation." );
                         std::ostringstream os;
                         PassVisitor<CodeGenerator> cg( os, options );
+                        PassVisitor<CodeGenerator> cg( os, pretty, genC, lineMarks );
                         os << "forall(";
                         cg.pass.genCommaList( funcType->forall.begin(), funcType->forall.end() );
 …
                 if ( ! refType->parameters.empty() ) {
                         std::ostringstream os;
                         PassVisitor<CodeGenerator> cg( os, options );
+                        PassVisitor<CodeGenerator> cg( os, pretty, genC, lineMarks );
                         os << "(";
                         cg.pass.genCommaList( refType->parameters.begin(), refType->parameters.end() );
 …
         void GenType::postvisit( StructInstType * structInst )  {
                 typeString = structInst->name + handleGeneric( structInst ) + " " + typeString;
                 if ( options.genC ) typeString = "struct " + typeString;
+                if ( genC ) typeString = "struct " + typeString;
                 handleQualifiers( structInst );
+        }
 …
         void GenType::postvisit( UnionInstType * unionInst ) {
                 typeString = unionInst->name + handleGeneric( unionInst ) + " " + typeString;
                 if ( options.genC ) typeString = "union " + typeString;
+                if ( genC ) typeString = "union " + typeString;
                 handleQualifiers( unionInst );
+        }
 …
         void GenType::postvisit( EnumInstType * enumInst ) {
                 typeString = enumInst->name + " " + typeString;
                 if ( options.genC ) typeString = "enum " + typeString;
+                if ( genC ) typeString = "enum " + typeString;
                 handleQualifiers( enumInst );
+        }
 …
         void GenType::postvisit( TupleType * tupleType ) {
                 assertf( ! options.genC, "Tuple types should not reach code generation." );
+                assertf( ! genC, "Tuple types should not reach code generation." );
                 unsigned int i = 0;
                 std::ostringstream os;
 …
                 for ( Type * t : *tupleType ) {
                         i++;
                         os << genType( t, "", options ) << (i == tupleType->size() ? "" : ", ");
+                        os << genType( t, "", pretty, genC, lineMarks ) << (i == tupleType->size() ? "" : ", ");
+                }
                 os << "] ";
 …
         void GenType::postvisit( ZeroType * zeroType ) {
                 // ideally these wouldn't hit codegen at all, but should be safe to make them ints
                 typeString = (options.pretty ? "zero_t " : "long int ") + typeString;
+                typeString = (pretty ? "zero_t " : "long int ") + typeString;
                 handleQualifiers( zeroType );
+        }
 …
         void GenType::postvisit( OneType * oneType ) {
                 // ideally these wouldn't hit codegen at all, but should be safe to make them ints
                 typeString = (options.pretty ? "one_t " : "long int ") + typeString;
+                typeString = (pretty ? "one_t " : "long int ") + typeString;
                 handleQualifiers( oneType );
+        }
         void GenType::postvisit( GlobalScopeType * globalType ) {
                 assertf( ! options.genC, "Global scope type should not reach code generation." );
+                assertf( ! genC, "Global scope type should not reach code generation." );
                 handleQualifiers( globalType );
+        }
         void GenType::postvisit( TraitInstType * inst ) {
                 assertf( ! options.genC, "Trait types should not reach code generation." );
+                assertf( ! genC, "Trait types should not reach code generation." );
                 typeString = inst->name + " " + typeString;
                 handleQualifiers( inst );
 …
         void GenType::postvisit( TypeofType * typeof ) {
                 std::ostringstream os;
                 PassVisitor<CodeGenerator> cg( os, options );
+                PassVisitor<CodeGenerator> cg( os, pretty, genC, lineMarks );
                 os << "typeof(";
                 typeof->expr->accept( cg );
 …
         void GenType::postvisit( QualifiedType * qualType ) {
                 assertf( ! options.genC, "Qualified types should not reach code generation." );
                 std::ostringstream os;
                 os << genType( qualType->parent, "", options ) << "." << genType( qualType->child, "", options ) << typeString;
+                assertf( ! genC, "Qualified types should not reach code generation." );
+                std::ostringstream os;
+                os << genType( qualType->parent, "", pretty, genC, lineMarks ) << "." << genType( qualType->child, "", pretty, genC, lineMarks ) << typeString;
                 typeString = os.str();
                 handleQualifiers( qualType );
 …
                         typeString = "_Atomic " + typeString;
                 } // if
                 if ( type->get_lvalue() && ! options.genC ) {
+                if ( type->get_lvalue() && ! genC ) {
                         // when not generating C code, print lvalue for debugging.
                         typeString = "lvalue " + typeString;

src/CodeGen/GenType.h

-              r933f32f
+              r6a9d4b4
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Andrew Beach
 // Last Modified On : Tue Apr 30 11:47:00 2019
 // Update Count     : 3
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Fri Jul 21 22:17:23 2017
+// Update Count     : 2
 //
 …
 #include <string>  // for string
-#include "CodeGen/Options.h" // for Options
 class Type;
 namespace CodeGen {
-        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 );

src/CodeGen/module.mk

-              r933f32f
+              r6a9d4b4
 #       ArgTweak/Mutate.cc
 SRC_CODEGEN = \
+SRC +=  CodeGen/Generate.cc \
         CodeGen/CodeGenerator.cc \
+        CodeGen/GenType.cc \
+        CodeGen/FixNames.cc \
         CodeGen/FixMain.cc \
-        CodeGen/GenType.cc \
         CodeGen/OperatorTable.cc
-SRC += $(SRC_CODEGEN) CodeGen/Generate.cc CodeGen/FixNames.cc
-SRCDEMANGLE += $(SRC_CODEGEN)

src/Common/Assert.cc

-              r933f32f
+              r6a9d4b4
+}
-void abort(const char *fmt, ... ) noexcept __attribute__((noreturn, format(printf, 1, 2)));
-void abort(const char *fmt, ... ) noexcept {
-        va_list args;
-        va_start( args, fmt );
-        vfprintf( stderr, fmt, args );
-        va_end( args );
-        fprintf( stderr, "\n" );
-        abort();
+}
 // Local Variables: //
 // tab-width: 4 //

src/Common/PassVisitor.h

-              r933f32f
+              r6a9d4b4
 #include <stack>
+#include <type_traits>
+#include "Common/Stats.h"
 #include "Common/utility.h"
 …
         virtual void visit( ConstructorInit * ctorInit ) override final;
+        virtual void visit( Subrange * subrange ) override final;
         virtual void visit( Constant * constant ) override final;
 …
         virtual Initializer * mutate( ConstructorInit * ctorInit ) override final;
+        virtual Subrange * mutate( Subrange * subrange ) override final;
         virtual Constant * mutate( Constant * constant ) override final;
 …
         auto                                    get_env_ptr    () -> decltype(env_impl( pass, 0)) { return env_impl( pass, 0); }
+        TypeSubstitution **             get_env_ptr    () { return env_impl             ( pass, 0); }
         std::list< Statement* > *       get_beforeStmts() { return stmtsToAddBefore_impl( pass, 0); }
         std::list< Statement* > *       get_afterStmts () { return stmtsToAddAfter_impl ( pass, 0); }
 …
 };
-class WithConstTypeSubstitution {
-protected:
-        WithConstTypeSubstitution() = default;
-        ~WithConstTypeSubstitution() = default;
-public:
-        const TypeSubstitution * env = nullptr;
-};
 class WithStmtsToAdd {
 protected:
 …
 };
-#include "Common/Stats.h"
-extern struct PassVisitorStats {
-        size_t depth = 0;
-        Stats::Counters::MaxCounter<double> * max = nullptr;
-        Stats::Counters::AverageCounter<double> * avg = nullptr;
-} pass_visitor_stats;
 #include "SynTree/TypeSubstitution.h"
 #include "PassVisitor.impl.h"

src/Common/PassVisitor.impl.h

-              r933f32f
+              r6a9d4b4
 #define MUTATE_END( type, node )                \
+        auto __return = call_postmutate< type * >( node ); \
+        assert( __return ); \
+        return __return;
+        return call_postmutate< type * >( node ); \
 …
         SemanticErrorException errors;
-        pass_visitor_stats.depth++;
-        pass_visitor_stats.max->push(pass_visitor_stats.depth);
-        pass_visitor_stats.avg->push(pass_visitor_stats.depth);
         for ( std::list< Declaration* >::iterator i = decls.begin(); ; ++i ) {
                 // splice in new declarations after previous decl
                 if ( !empty( afterDecls ) ) { decls.splice( i, *afterDecls ); }
 …
                 if ( !empty( beforeDecls ) ) { decls.splice( i, *beforeDecls ); }
+        }
-        pass_visitor_stats.depth--;
         if ( ! errors.isEmpty() ) {
                 throw errors;
 …
         SemanticErrorException errors;
-        pass_visitor_stats.depth++;
-        pass_visitor_stats.max->push(pass_visitor_stats.depth);
-        pass_visitor_stats.avg->push(pass_visitor_stats.depth);
         for ( std::list< Declaration* >::iterator i = decls.begin(); ; ++i ) {
                 // splice in new declarations after previous decl
 …
                 if ( !empty( beforeDecls ) ) { decls.splice( i, *beforeDecls ); }
+        }
-        pass_visitor_stats.depth--;
         if ( ! errors.isEmpty() ) {
                 throw errors;
 …
         if ( ! visitor.get_visit_children() ) return;
         SemanticErrorException errors;
-        pass_visitor_stats.depth++;
-        pass_visitor_stats.max->push(pass_visitor_stats.depth);
-        pass_visitor_stats.avg->push(pass_visitor_stats.depth);
         for ( typename Container::iterator i = container.begin(); i != container.end(); ++i ) {
                 try {
 …
+                }
+        }
-        pass_visitor_stats.depth--;
         if ( ! errors.isEmpty() ) {
                 throw errors;
 …
 template< typename Container, typename pass_type >
 inline void maybeMutate_impl( Container & container, PassVisitor< pass_type > & mutator ) {
         if ( ! mutator.get_visit_children() ) return;
         SemanticErrorException errors;
-        pass_visitor_stats.depth++;
-        pass_visitor_stats.max->push(pass_visitor_stats.depth);
-        pass_visitor_stats.avg->push(pass_visitor_stats.depth);
         for ( typename Container::iterator i = container.begin(); i != container.end(); ++i ) {
                 try {
 …
                 } // try
         } // for
-        pass_visitor_stats.depth--;
         if ( ! errors.isEmpty() ) {
                 throw errors;
 …
         DeclList_t* afterDecls  = get_afterDecls();
-        pass_visitor_stats.depth++;
-        pass_visitor_stats.max->push(pass_visitor_stats.depth);
-        pass_visitor_stats.avg->push(pass_visitor_stats.depth);
         for ( std::list< Statement* >::iterator i = statements.begin(); i != statements.end(); ++i ) {
 …
                 try {
                         func( *i );
-                        assert( *i );
                         assert(( empty( beforeStmts ) && empty( afterStmts ))
                             || ( empty( beforeDecls ) && empty( afterDecls )) );
 …
                 if ( !empty( beforeStmts ) ) { statements.splice( i, *beforeStmts ); }
+        }
-        pass_visitor_stats.depth--;
         if ( !empty( afterDecls ) ) { splice( std::back_inserter( statements ), afterDecls); }
 …
         // don't want statements from outer CompoundStmts to be added to this CompoundStmt
         ValueGuardPtr< typename std::remove_pointer<decltype(get_env_ptr())>::type >  oldEnv( get_env_ptr() );
+        ValueGuardPtr< TypeSubstitution * >  oldEnv        ( get_env_ptr    () );
         ValueGuardPtr< DeclList_t >          oldBeforeDecls( get_beforeDecls() );
         ValueGuardPtr< DeclList_t >          oldAfterDecls ( get_afterDecls () );
 …
         // don't want statements from outer CompoundStmts to be added to this StmtExpr
         ValueGuardPtr< typename std::remove_pointer<decltype(get_env_ptr())>::type >  oldEnv( get_env_ptr() );
+        ValueGuardPtr< TypeSubstitution * >      oldEnv        ( get_env_ptr() );
         ValueGuardPtr< std::list< Statement* > > oldBeforeStmts( get_beforeStmts() );
         ValueGuardPtr< std::list< Statement* > > oldAfterStmts ( get_afterStmts () );
 …
         // don't want statements from outer CompoundStmts to be added to this StmtExpr
         ValueGuardPtr< typename std::remove_pointer<decltype(get_env_ptr())>::type >  oldEnv( get_env_ptr() );
+        ValueGuardPtr< TypeSubstitution * >      oldEnv        ( get_env_ptr() );
         ValueGuardPtr< std::list< Statement* > > oldBeforeStmts( get_beforeStmts() );
         ValueGuardPtr< std::list< Statement* > > oldAfterStmts ( get_afterStmts () );
 …
 //--------------------------------------------------------------------------
+// Subrange
+template< typename pass_type >
+void PassVisitor< pass_type >::visit( Subrange * node ) {
+        VISIT_START( node );
+        VISIT_END( node );
+}
+template< typename pass_type >
+Subrange * PassVisitor< pass_type >::mutate( Subrange * node  )  {
+        MUTATE_START( node );
+        MUTATE_END( Subrange, node );
+}
+//--------------------------------------------------------------------------
 // Attribute
 template< typename pass_type >

src/Common/PassVisitor.proto.h

-              r933f32f
+              r6a9d4b4
 static inline type * name##_impl( __attribute__((unused)) pass_type& pass, __attribute__((unused)) long unused ) { return nullptr;}    \
 FIELD_PTR( const TypeSubstitution *, env )
+FIELD_PTR( TypeSubstitution *, env )
 FIELD_PTR( std::list< Statement* >, stmtsToAddBefore )
 FIELD_PTR( std::list< Statement* >, stmtsToAddAfter  )
 …
 FIELD_PTR( PassVisitor<pass_type> * const, visitor )
-#undef FIELD_PTR
 //---------------------------------------------------------
 // Indexer
 …
 INDEXER_FUNC2( addWith   , std::list< Expression * > &, BaseSyntaxNode * );
-#undef INDEXER_FUNC1
-#undef INDEXER_FUNC2
 template<typename pass_type>

src/Common/SemanticError.h

r933f32f	r6a9d4b4
17	17
18	18	#include "ErrorObjects.h"
19		~~#include "AST/Node.hpp"~~
20	19	#include <cstring>
21	20

src/Common/module.mk

-              r933f32f
+              r6a9d4b4
 ###############################################################################
+SRC_COMMON = \
+      Common/Assert.cc \
+      Common/Eval.cc \
+      Common/PassVisitor.cc \
+      Common/SemanticError.cc \
+      Common/Stats/Counter.cc \
+      Common/Stats/Heap.cc \
+      Common/Stats/Stats.cc \
+      Common/Stats/Time.cc \
+      Common/UniqueName.cc
+SRC += $(SRC_COMMON) Common/DebugMalloc.cc
+SRCDEMANGLE += $(SRC_COMMON)
+SRC += Common/SemanticError.cc \
+       Common/UniqueName.cc \
+       Common/DebugMalloc.cc \
+       Common/Assert.cc \
+       Common/Heap.cc \
+       Common/Eval.cc

src/Common/utility.h

-              r933f32f
+              r6a9d4b4
 std::pair<long long int, bool> eval(Expression * expr);
+namespace ast {
+        class Expr;
+}
+std::pair<long long int, bool> eval(const ast::Expr * expr);
+// -----------------------------------------------------------------------------
+/// Reorders the input range in-place so that the minimal-value elements according to the
+/// comparator are in front;
+// -----------------------------------------------------------------------------
+/// Reorders the input range in-place so that the minimal-value elements according to the
+/// comparator are in front;
 /// returns the iterator after the last minimal-value element.
 template<typename Iter, typename Compare>
 Iter sort_mins( Iter begin, Iter end, Compare& lt ) {
         if ( begin == end ) return end;
         Iter min_pos = begin;
         for ( Iter i = begin + 1; i != end; ++i ) {

src/CompilationState.cc

-              r933f32f
+              r6a9d4b4
 // Author           : Rob Schluntz
 // Created On       : Mon Ju1 30 10:47:01 2018
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri May  3 13:45:23 2019
 // Update Count     : 4
+// Last Modified By : Rob Schluntz
+// Last Modified On : Mon Ju1 30 10:46:25 2018
+// Update Count     : 2
 //
+int
+bool
         astp = false,
         bresolvep = false,
 …
         libcfap = false,
         nopreludep = false,
         genproto = false,
+        noprotop = false,
         nomainp = false,
         parsep = false,

src/CompilationState.h

-              r933f32f
+              r6a9d4b4
 // Author           : Rob Schluntz
 // Created On       : Mon Ju1 30 10:47:01 2018
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri May  3 13:43:21 2019
 // Update Count     : 4
+// Last Modified By : Rob Schluntz
+// Last Modified On : Mon Ju1 30 10:46:25 2018
+// Update Count     : 2
 //
 extern int yydebug;                   // set for -g flag (Grammar)
 extern int
+extern bool
         astp,
         bresolvep,
 …
         libcfap,
         nopreludep,
         genproto,
+        noprotop,
         nomainp,
         parsep,

src/Concurrency/Waitfor.cc

r933f32f	r6a9d4b4
11	11	// Last Modified By :
12	12	// Last Modified On :
13		// Update Count : 7
	13	// Update Count : 5
14	14	//
15	15

src/Concurrency/module.mk

-              r933f32f
+              r6a9d4b4
 ###############################################################################
 SRC += Concurrency/Keywords.cc Concurrency/Waitfor.cc
 SRCDEMANGLE += Concurrency/Keywords.cc
+SRC += Concurrency/Keywords.cc \
+       Concurrency/Waitfor.cc

src/ControlStruct/ExceptTranslate.cc

-              r933f32f
+              r6a9d4b4
 // Author           : Andrew Beach
 // Created On       : Wed Jun 14 16:49:00 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed Feb 13 18:15:29 2019
 // Update Count     : 11
+// Last Modified By : Andrew Beach
+// Last Modified On : Thr Aug 17 17:19:00 2017
+// Update Count     : 9
 //
 …
                                 return create_terminate_rethrow( throwStmt );
                         } else {
                                 abort("Invalid throw in %s at %i\n",
+                                assertf(false, "Invalid throw in %s at %i\n",
                                         throwStmt->location.filename.c_str(),
                                         throwStmt->location.first_line);
+                                return nullptr;
+                        }
                 } else {
 …
                                 return create_resume_rethrow( throwStmt );
                         } else {
                                 abort("Invalid throwResume in %s at %i\n",
+                                assertf(false, "Invalid throwResume in %s at %i\n",
                                         throwStmt->location.filename.c_str(),
                                         throwStmt->location.first_line);
+                                return nullptr;
+                        }
+                }

src/ControlStruct/ForExprMutator.cc

-              r933f32f
+              r6a9d4b4
 // Author           : Rodolfo G. Esteves
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Mon Mar 11 22:26:52 2019
 // Update Count     : 14
+// Last Modified By : Andrew Beach
+// Last Modified On : Fri Aug 18 10:22:00 2017
+// Update Count     : 12
 //
 …
 namespace ControlStruct {
         Statement * hoist( Statement * originalStmt, std::list<Statement *> & init ) {
+        Statement *hoist( Statement *originalStmt, std::list<Statement *> &init ) {
                 // If no hoisting is needed, skip:
                 if ( 0 == init.size() ) {
 …
                 // Create compound statement, move initializers outside,
                 // the resut of the original stays as is.
                 CompoundStmt * block = new CompoundStmt();
                 std::list<Statement *> & stmts = block->get_kids();
+                CompoundStmt *block = new CompoundStmt();
+                std::list<Statement *> &stmts = block->get_kids();
                 stmts.splice( stmts.end(), init );
 …
+        }
         Statement * ForExprMutator::postmutate( IfStmt * ifStmt ) {
+        Statement *ForExprMutator::postmutate( IfStmt *ifStmt ) {
                 return hoist( ifStmt, ifStmt->initialization );
+        }
         Statement * ForExprMutator::postmutate( ForStmt * forStmt ) {
+        Statement *ForExprMutator::postmutate( ForStmt *forStmt ) {
                 // hoist any initializer declarations to make them C89 (rather than C99)
                 return hoist( forStmt, forStmt->initialization );
+        }
         Statement * ForExprMutator::postmutate( WhileStmt * whileStmt ) {
+        Statement *ForExprMutator::postmutate( WhileStmt *whileStmt ) {
                 return hoist( whileStmt, whileStmt->initialization );
+        }

src/ControlStruct/LabelFixer.cc

-              r933f32f
+              r6a9d4b4
 // Author           : Rodolfo G. Esteves
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Mon Mar 11 22:26:02 2019
 // Update Count     : 159
+// Last Modified By : Rob Schluntz
+// Last Modified On : Tue Jul 28 13:32:43 2015
+// Update Count     : 156
 //
 …
+        }
         LabelFixer::LabelFixer( LabelGenerator * gen ) : generator ( gen ) {
+        LabelFixer::LabelFixer( LabelGenerator *gen ) : generator ( gen ) {
                 if ( generator == 0 )
                         generator = LabelGenerator::getGenerator();
 …
         // prune to at most one label definition for each statement
         void LabelFixer::previsit( Statement * stmt ) {
+        void LabelFixer::previsit( Statement *stmt ) {
                 std::list< Label > &labels = stmt->get_labels();
 …
+        }
         void LabelFixer::previsit( BranchStmt * branchStmt ) {
+        void LabelFixer::previsit( BranchStmt *branchStmt ) {
                 previsit( ( Statement *)branchStmt );
 …
         // 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 ) {
+        // 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 );
 …
                 } // 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();
+        }
 …
         // Builds a table that maps a label to its defining statement.
         std::map<Label, Statement * > * LabelFixer::resolveJumps() throw ( SemanticErrorException ) {
+        std::map<Label, Statement * > *LabelFixer::resolveJumps() throw ( SemanticErrorException ) {
                 std::map< Label, Statement * > *ret = new std::map< Label, Statement * >();
                 for ( std::map< Label, Entry * >::iterator i = labelTable.begin(); i != labelTable.end(); ++i ) {

src/ControlStruct/LabelGenerator.cc

-              r933f32f
+              r6a9d4b4
 // Author           : Rodolfo G. Esteves
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Mon Mar 11 22:23:20 2019
 // Update Count     : 15
+// Last Modified By : Andrew Beach
+// Last Modified On : Thr Aug 14 14:14:00 2015
+// Update Count     : 14
 //
 …
 namespace ControlStruct {
         LabelGenerator * LabelGenerator::labelGenerator = 0;
+        LabelGenerator *LabelGenerator::labelGenerator = 0;
         LabelGenerator * LabelGenerator::getGenerator() {
+        LabelGenerator *LabelGenerator::getGenerator() {
                 if ( LabelGenerator::labelGenerator == 0 )
                         LabelGenerator::labelGenerator = new LabelGenerator();
                 return labelGenerator;
+        }
 …
                 if ( stmt && ! stmt->get_labels().empty() ) {
                         os << "_" << stmt->get_labels().front() << "__";
                 } // if
+                }
                 std::string ret = os.str();
                 Label l( ret );

src/ControlStruct/module.mk

-              r933f32f
+              r6a9d4b4
 ###############################################################################
+SRC_CONTROLSTRUCT = \
+SRC +=  ControlStruct/LabelGenerator.cc \
+        ControlStruct/LabelFixer.cc \
+        ControlStruct/MLEMutator.cc \
+        ControlStruct/Mutate.cc \
         ControlStruct/ForExprMutator.cc \
+        ControlStruct/LabelFixer.cc \
+        ControlStruct/LabelGenerator.cc \
+        ControlStruct/MLEMutator.cc \
+        ControlStruct/Mutate.cc
+SRC += $(SRC_CONTROLSTRUCT) ControlStruct/ExceptTranslate.cc
+SRCDEMANGLE += $(SRC_CONTROLSTRUCT)
+        ControlStruct/ExceptTranslate.cc

src/GenPoly/Box.cc

-              r933f32f
+              r6a9d4b4
                 /// Replaces polymorphic return types with out-parameters, replaces calls to polymorphic functions with adapter calls as needed, and adds appropriate type variables to the function call
                 class Pass1 final : public BoxPass, public WithConstTypeSubstitution, public WithStmtsToAdd, public WithGuards, public WithVisitorRef<Pass1>, public WithShortCircuiting {
+                class Pass1 final : public BoxPass, public WithTypeSubstitution, public WithStmtsToAdd, public WithGuards, public WithVisitorRef<Pass1>, public WithShortCircuiting {
                   public:
                         Pass1();
 …
                 /// * Calculates polymorphic offsetof expressions from offset array
                 /// * Inserts dynamic calculation of polymorphic type layouts where needed
                 class PolyGenericCalculator final : public BoxPass, public WithGuards, public WithVisitorRef<PolyGenericCalculator>, public WithStmtsToAdd, public WithDeclsToAdd, public WithConstTypeSubstitution {
+                class PolyGenericCalculator final : public BoxPass, public WithGuards, public WithVisitorRef<PolyGenericCalculator>, public WithStmtsToAdd, public WithDeclsToAdd, public WithTypeSubstitution {
                 public:
                         PolyGenericCalculator();

src/GenPoly/GenPoly.cc

-              r933f32f
+              r6a9d4b4
+        }
         bool needsBoxing( Type * param, Type * arg, const TyVarMap &exprTyVars, const TypeSubstitution * env ) {
+        bool needsBoxing( Type * param, Type * arg, const TyVarMap &exprTyVars, TypeSubstitution * env ) {
                 // is parameter is not polymorphic, don't need to box
                 if ( ! isPolyType( param, exprTyVars ) ) return false;
 …
+        }
         bool needsBoxing( Type * param, Type * arg, ApplicationExpr * appExpr, const TypeSubstitution * env ) {
+        bool needsBoxing( Type * param, Type * arg, ApplicationExpr * appExpr, TypeSubstitution * env ) {
                 FunctionType * function = getFunctionType( appExpr->function->result );
                 assertf( function, "ApplicationExpr has non-function type: %s", toString( appExpr->function->result ).c_str() );

src/GenPoly/GenPoly.h

-              r933f32f
+              r6a9d4b4
         /// true if arg requires boxing given exprTyVars
         bool needsBoxing( Type * param, Type * arg, const TyVarMap &exprTyVars, const TypeSubstitution * env );
+        bool needsBoxing( Type * param, Type * arg, const TyVarMap &exprTyVars, TypeSubstitution * env );
         /// true if arg requires boxing in the call to appExpr
         bool needsBoxing( Type * param, Type * arg, ApplicationExpr * appExpr, const TypeSubstitution * env );
+        bool needsBoxing( Type * param, Type * arg, ApplicationExpr * appExpr, TypeSubstitution * env );
         /// Adds the type variable `tyVar` to `tyVarMap`

src/GenPoly/InstantiateGeneric.cc

r933f32f	r6a9d4b4
168	168
169	169	/// Mutator pass that replaces concrete instantiations of generic types with actual struct declarations, scoped appropriately
170		struct GenericInstantiator final : public With~~Const~~TypeSubstitution, public WithDeclsToAdd, public WithVisitorRef<GenericInstantiator>, public WithGuards {
	170	struct GenericInstantiator final : public WithTypeSubstitution, public WithDeclsToAdd, public WithVisitorRef<GenericInstantiator>, public WithGuards {
171	171	/// Map of (generic type, parameter list) pairs to concrete type instantiations
172	172	InstantiationMap< AggregateDecl, AggregateDecl > instantiations;

src/GenPoly/Specialize.cc

-              r933f32f
+              r6a9d4b4
 namespace GenPoly {
         struct Specialize final : public WithConstTypeSubstitution, public WithStmtsToAdd, public WithVisitorRef<Specialize> {
+        struct Specialize final : public WithTypeSubstitution, public WithStmtsToAdd, public WithVisitorRef<Specialize> {
                 Expression * postmutate( ApplicationExpr *applicationExpr );
                 Expression * postmutate( CastExpr *castExpr );
 …
         /// Looks up open variables in actual type, returning true if any of them are bound in the environment or formal type.
         bool needsPolySpecialization( Type *formalType, Type *actualType, const TypeSubstitution *env ) {
+        bool needsPolySpecialization( Type *formalType, Type *actualType, TypeSubstitution *env ) {
                 if ( env ) {
                         using namespace ResolvExpr;
 …
+        }
         bool needsSpecialization( Type *formalType, Type *actualType, const TypeSubstitution *env ) {
+        bool needsSpecialization( Type *formalType, Type *actualType, TypeSubstitution *env ) {
                 return needsPolySpecialization( formalType, actualType, env ) || needsTupleSpecialization( formalType, actualType );
+        }

src/GenPoly/module.mk

r933f32f	r6a9d4b4
22	22	GenPoly/FindFunction.cc \
23	23	GenPoly/InstantiateGeneric.cc
24
25		~~SRCDEMANGLE += GenPoly/GenPoly.cc GenPoly/Lvalue.cc~~
26

src/InitTweak/FixInit.cc

-              r933f32f
+              r6a9d4b4
 // Created On       : Wed Jan 13 16:29:30 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed Feb 13 18:15:56 2019
 // Update Count     : 76
+// Last Modified On : Wed Jun 21 17:35:05 2017
+// Update Count     : 74
 //
 #include "FixInit.h"
 …
                 };
                 struct InsertImplicitCalls : public WithConstTypeSubstitution {
+                struct InsertImplicitCalls : public WithTypeSubstitution {
                         /// wrap function application expressions as ImplicitCopyCtorExpr nodes so that it is easy to identify which
                         /// function calls need their parameters to be copy constructed

src/InitTweak/InitTweak.cc

-              r933f32f
+              r6a9d4b4
 #include <memory>                  // for __shared_ptr
-#include "AST/Expr.hpp"
-#include "AST/Stmt.hpp"
-#include "AST/Type.hpp"
 #include "Common/PassVisitor.h"
 #include "Common/SemanticError.h"  // for SemanticError
 …
 #include "Tuples/Tuples.h"         // for Tuples::isTtype
+class UntypedValofExpr;
 namespace InitTweak {
         namespace {
 …
                         assert( false );
+                }
-                // template<typename CallExpr>
-                // const ast::Expr * callArg( const CallExpr * call, unsigned int pos ) {
-                //      if( pos >= call->args.size() ) {
-                //              assertf( false, "getCallArg for argument that doesn't exist: (%u); %s.",
-                //                      pos, toString( call ).c_str() );
-                //      }
-                //      for ( const ast::Expr * arg : call->args ) {
-                //              if ( pos == 0 ) return arg;
-                //              --pos;
-                //      }
-                //      assert( false );
-                // }
+        }
 …
                         assertf( false, "Unexpected expression type passed to getCallArg: %s", toString( callExpr ).c_str() );
+                }
+        }
-        const ast::Expr * getCallArg( const ast::Expr * call, unsigned pos ) {
-                (void)call;
-                (void)pos;
-                #warning unimplemented; needs to build AST/Expr.cpp
-                assertf(false, "unimplemented; needs to build AST/Expr.cpp");
-                // if ( auto app = dynamic_cast< const ast::ApplicationExpr * >( call ) ) {
-                //      return callArg( app, pos );
-                // } else if ( auto untyped = dynamic_cast< const ast::UntypedExpr * >( call ) ) {
-                //      return callArg( untyped, pos );
-                // } else if ( auto tupleAssn = dynamic_cast< const ast::TupleAssignExpr * >( call ) ) {
-                //      const std::list<ast::ptr<ast::Stmt>>& stmts = tupleAssn->stmtExpr->stmts->kids;
-                //      assertf( ! stmts.empty(), "TupleAssignExpr missing statements." );
-                //      const ExprStmt * stmt = strict_dynamic_cast< const ast::ExprStmt * >( stmts.back() );
-                //      const TupleExpr * tuple = strict_dynamic_cast< const ast::TupleExpr * >( stmt->expr );
-                //      assertf( ! tuple->exprs.empty(), "TupleAssignExpr has empty tuple expr.");
-                //      return getCallArg( tuple->exprs.front(), pos );
-                // } else if ( auto ctor = dynamic_cast< const ast::ImplicitCopyCtorExpr * >( call ) ) {
-                //      return getCallArg( ctor->callExpr, pos );
-                // } else {
-                //      assertf( false, "Unexpected expression type passed to getCallArg: %s",
-                //              toString( call ).c_str() );
-                // }
+        }
 …
+                }
+        }
-        const ast::Type* getPointerBase( const ast::Type* t ) {
-                (void)t;
-                #warning needs to build Type.cpp before inclusion
-                assertf(false, "needs to build Type.cpp before inclusion");
-                // if ( const auto * p = dynamic_cast< const ast::PointerType * >( t ) ) {
-                //      return p->base;
-                // } else if ( const auto * a = dynamic_cast< const ast::ArrayType * >( t ) ) {
-                //      return a->base;
-                // } else if ( const auto * r = dynamic_cast< const ast::ReferenceType * >( t ) ) {
-                //      return r->base;
-                // } else return nullptr;
+        }
         Type * isPointerType( Type * type ) {

src/InitTweak/InitTweak.h

-              r933f32f
+              r6a9d4b4
 #include <string>             // for string, allocator
-#include "AST/Fwd.hpp"        // for AST nodes
 #include "SynTree/SynTree.h"  // for Visitor Nodes
 …
         /// returns the argument to a call expression in position N indexed from 0
         Expression *& getCallArg( Expression * callExpr, unsigned int pos );
-        const ast::Expr * getCallArg( const ast::Expr * call, unsigned pos );
         /// returns the base type of a PointerType or ArrayType, else returns NULL
         Type * getPointerBase( Type * );
-        const ast::Type* getPointerBase( const ast::Type* );
         /// returns the argument if it is a PointerType or ArrayType, else returns NULL

src/InitTweak/module.mk

r933f32f	r6a9d4b4
20	20	InitTweak/InitTweak.cc
21	21
22		~~SRCDEMANGLE += InitTweak/GenInit.cc \~~
23		~~InitTweak/InitTweak.cc~~
24

src/MakeLibCfa.cc

-              r933f32f
+              r6a9d4b4
 // Author           : Richard C. Bilson
 // Created On       : Sat May 16 10:33:33 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sun Feb 17 21:08:09 2019
 // Update Count     : 41
+// Last Modified By : Rob Schluntz
+// Last Modified On : Fri Apr 22 13:54:15 2016
+// Update Count     : 40
 //
 …
         } // namespace
 } // namespace LibCfa
-// Local Variables: //
-// tab-width: 4 //
-// End: //

src/Makefile.am

-              r933f32f
+              r6a9d4b4
 ## Author           : Peter A. Buhr
 ## Created On       : Sun May 31 08:51:46 2015
 ## Last Modified By : Peter A. Buhr
 ## Last Modified On : Fri Feb 15 09:44:09 2019
 ## Update Count     : 97
+## Last Modified By : Andrew Beach
+## Last Modified On : Tus Jul 25 10:34:00 2017
+## Update Count     : 76
 ###############################################################################
 …
 SRC = main.cc \
+      MakeLibCfa.cc \
+      CompilationState.cc
+SRCDEMANGLE = CompilationState.cc
+                        MakeLibCfa.cc \
+                        CompilationState.cc
 MAINTAINERCLEANFILES =
 MOSTLYCLEANFILES =
+MOSTLYCLEANFILES = Parser/gcc-flags.h
+if WITH_LIBPROFILER
+LIBPROFILER = -lprofiler
+endif
+Parser/gcc-flags.h :
+        ${AM_V_GEN}$(CC) -dM -E - < /dev/null | sed 's/define /define __GCC__/' > $(@)
+if WITH_LIBTCMALLOC
+LIBTCMALLOC = -ltcmalloc
+TCMALLOCFLAG = -DTCMALLOC
+endif
+Parser/lex.ll : Parser/gcc-flags.h
 include CodeGen/module.mk
 …
 include Virtual/module.mk
-$(addprefix $(srcdir)/, ResolvExpr/ConversionCost.cc ResolvExpr/CommonType.cc SymTab/ManglerCommon.cc) : $(srcdir)/SynTree/Type.h
-$(srcdir)/SynTree/Type.h : BasicTypes-gen.cc
-        ${AM_V_GEN}${CXXCOMPILE} $< -o BasicTypes-gen -Wall -Wextra
-        @./BasicTypes-gen
-        @rm BasicTypes-gen
 # put into lib for now
 cfa_cpplibdir = $(CFA_LIBDIR)
 cfa_cpplib_PROGRAMS = ../driver/cfa-cpp demangler
 ___driver_cfa_cpp_SOURCES = $(SRC)
 ___driver_cfa_cpp_LDADD = -ldl $(LIBPROFILER) $(LIBTCMALLOC)
+___driver_cfa_cpp_LDADD = -ldl                  # yywrap
 AM_CXXFLAGS = @HOST_FLAGS@ -Wno-deprecated -Wall -Wextra -DDEBUG_ALL -I./Parser -I$(srcdir)/Parser -I$(srcdir)/include -DYY_NO_INPUT -O3 -g -std=c++14 $(TCMALLOCFLAG)
+AM_CXXFLAGS = @HOST_FLAGS@ -Wno-deprecated -Wall -Wextra -DDEBUG_ALL -I./Parser -I$(srcdir)/Parser -I$(srcdir)/include -DYY_NO_INPUT -O2 -g -std=c++14
 AM_LDFLAGS  = @HOST_FLAGS@ -Xlinker -export-dynamic
 ARFLAGS     = cr
 …
 demangler_SOURCES = SymTab/demangler.cc # test driver for the demangler, also useful as a sanity check that libdemangle.a is complete
 demangler_LDADD = libdemangle.a -ldl                    # yywrap
+demangler_LDADD = libdemangle.a     # yywrap
 noinst_LIBRARIES = libdemangle.a
+libdemangle_a_SOURCES = $(SRCDEMANGLE)
+libdemangle_a_SOURCES = \
+        SymTab/Demangle.cc \
+        SymTab/ManglerCommon.cc \
+        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/Statement.cc \
+        SynTree/CompoundStmt.cc \
+        SynTree/DeclStmt.cc \
+        SynTree/Declaration.cc \
+        SynTree/DeclarationWithType.cc \
+        SynTree/ObjectDecl.cc \
+        SynTree/FunctionDecl.cc \
+        SynTree/AggregateDecl.cc \
+        SynTree/NamedTypeDecl.cc \
+        SynTree/TypeDecl.cc \
+        SynTree/Initializer.cc \
+        SynTree/TypeSubstitution.cc \
+        SynTree/Attribute.cc \
+        SynTree/DeclReplacer.cc \
+        CompilationState.cc \
+        CodeGen/CodeGenerator.cc \
+        CodeGen/FixMain.cc \
+        CodeGen/Generate.cc \
+        CodeGen/GenType.cc \
+        CodeGen/OperatorTable.cc \
+        Common/Assert.cc \
+        Common/Eval.cc \
+        Common/SemanticError.cc \
+        Common/UniqueName.cc \
+        Concurrency/Keywords.cc \
+        ControlStruct/ForExprMutator.cc \
+        ControlStruct/LabelFixer.cc \
+        ControlStruct/LabelGenerator.cc \
+        ControlStruct/MLEMutator.cc \
+        ControlStruct/Mutate.cc \
+        GenPoly/GenPoly.cc \
+        GenPoly/Lvalue.cc \
+        InitTweak/GenInit.cc \
+        InitTweak/InitTweak.cc \
+        Parser/LinkageSpec.cc \
+        ResolvExpr/AdjustExprType.cc \
+        ResolvExpr/Alternative.cc \
+        ResolvExpr/AlternativeFinder.cc \
+        ResolvExpr/ExplodedActual.cc \
+        ResolvExpr/CastCost.cc \
+        ResolvExpr/CommonType.cc \
+        ResolvExpr/ConversionCost.cc \
+        ResolvExpr/CurrentObject.cc \
+        ResolvExpr/FindOpenVars.cc \
+        ResolvExpr/Occurs.cc \
+        ResolvExpr/PolyCost.cc \
+        ResolvExpr/PtrsAssignable.cc \
+        ResolvExpr/PtrsCastable.cc \
+        ResolvExpr/RenameVars.cc \
+        ResolvExpr/ResolveAssertions.cc \
+        ResolvExpr/Resolver.cc \
+        ResolvExpr/ResolveTypeof.cc \
+        ResolvExpr/SpecCost.cc \
+        ResolvExpr/TypeEnvironment.cc \
+        ResolvExpr/Unify.cc \
+        SymTab/Autogen.cc \
+        SymTab/FixFunction.cc \
+        SymTab/Indexer.cc \
+        SymTab/Mangler.cc \
+        SymTab/Validate.cc \
+        Tuples/Explode.cc \
+        Tuples/TupleAssignment.cc \
+        Tuples/TupleExpansion.cc \
+        Validate/HandleAttributes.cc \
+        Validate/FindSpecialDecls.cc
 MAINTAINERCLEANFILES += ${libdir}/${notdir ${cfa_cpplib_PROGRAMS}}

src/Makefile.in

-              r933f32f
+              r6a9d4b4
 libdemangle_a_LIBADD =
 am__dirstamp = $(am__leading_dot)dirstamp
+am__objects_1 = CodeGen/CodeGenerator.$(OBJEXT) \
+        CodeGen/FixMain.$(OBJEXT) CodeGen/GenType.$(OBJEXT) \
+        CodeGen/OperatorTable.$(OBJEXT)
+am__objects_2 = Common/Assert.$(OBJEXT) Common/Eval.$(OBJEXT) \
+        Common/PassVisitor.$(OBJEXT) Common/SemanticError.$(OBJEXT) \
+        Common/Stats/Counter.$(OBJEXT) Common/Stats/Heap.$(OBJEXT) \
+        Common/Stats/Stats.$(OBJEXT) Common/Stats/Time.$(OBJEXT) \
+        Common/UniqueName.$(OBJEXT)
+am__objects_3 = ControlStruct/ForExprMutator.$(OBJEXT) \
+am_libdemangle_a_OBJECTS = SymTab/Demangle.$(OBJEXT) \
+        SymTab/ManglerCommon.$(OBJEXT) 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/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) CompilationState.$(OBJEXT) \
+        CodeGen/CodeGenerator.$(OBJEXT) CodeGen/FixMain.$(OBJEXT) \
+        CodeGen/Generate.$(OBJEXT) CodeGen/GenType.$(OBJEXT) \
+        CodeGen/OperatorTable.$(OBJEXT) Common/Assert.$(OBJEXT) \
+        Common/Eval.$(OBJEXT) Common/SemanticError.$(OBJEXT) \
+        Common/UniqueName.$(OBJEXT) Concurrency/Keywords.$(OBJEXT) \
+        ControlStruct/ForExprMutator.$(OBJEXT) \
         ControlStruct/LabelFixer.$(OBJEXT) \
         ControlStruct/LabelGenerator.$(OBJEXT) \
         ControlStruct/MLEMutator.$(OBJEXT) \
+        ControlStruct/Mutate.$(OBJEXT)
+am__objects_4 = ResolvExpr/AdjustExprType.$(OBJEXT) \
+        ControlStruct/Mutate.$(OBJEXT) GenPoly/GenPoly.$(OBJEXT) \
+        GenPoly/Lvalue.$(OBJEXT) InitTweak/GenInit.$(OBJEXT) \
+        InitTweak/InitTweak.$(OBJEXT) Parser/LinkageSpec.$(OBJEXT) \
+        ResolvExpr/AdjustExprType.$(OBJEXT) \
         ResolvExpr/Alternative.$(OBJEXT) \
         ResolvExpr/AlternativeFinder.$(OBJEXT) \
+        ResolvExpr/ExplodedActual.$(OBJEXT) \
         ResolvExpr/CastCost.$(OBJEXT) ResolvExpr/CommonType.$(OBJEXT) \
         ResolvExpr/ConversionCost.$(OBJEXT) \
         ResolvExpr/CurrentObject.$(OBJEXT) \
-        ResolvExpr/ExplodedActual.$(OBJEXT) \
         ResolvExpr/FindOpenVars.$(OBJEXT) ResolvExpr/Occurs.$(OBJEXT) \
         ResolvExpr/PolyCost.$(OBJEXT) \
 …
         ResolvExpr/SpecCost.$(OBJEXT) \
         ResolvExpr/TypeEnvironment.$(OBJEXT) \
+        ResolvExpr/Unify.$(OBJEXT)
+am__objects_5 = SymTab/Autogen.$(OBJEXT) SymTab/FixFunction.$(OBJEXT) \
+        ResolvExpr/Unify.$(OBJEXT) SymTab/Autogen.$(OBJEXT) \
+        SymTab/FixFunction.$(OBJEXT) SymTab/Indexer.$(OBJEXT) \
+        SymTab/Mangler.$(OBJEXT) SymTab/Validate.$(OBJEXT) \
+        Tuples/Explode.$(OBJEXT) Tuples/TupleAssignment.$(OBJEXT) \
+        Tuples/TupleExpansion.$(OBJEXT) \
+        Validate/HandleAttributes.$(OBJEXT) \
+        Validate/FindSpecialDecls.$(OBJEXT)
+libdemangle_a_OBJECTS = $(am_libdemangle_a_OBJECTS)
+am__installdirs = "$(DESTDIR)$(cfa_cpplibdir)"
+PROGRAMS = $(cfa_cpplib_PROGRAMS)
+am__objects_1 = main.$(OBJEXT) MakeLibCfa.$(OBJEXT) \
+        CompilationState.$(OBJEXT) CodeGen/Generate.$(OBJEXT) \
+        CodeGen/CodeGenerator.$(OBJEXT) CodeGen/GenType.$(OBJEXT) \
+        CodeGen/FixNames.$(OBJEXT) CodeGen/FixMain.$(OBJEXT) \
+        CodeGen/OperatorTable.$(OBJEXT) CodeTools/DeclStats.$(OBJEXT) \
+        CodeTools/ResolvProtoDump.$(OBJEXT) \
+        CodeTools/TrackLoc.$(OBJEXT) Concurrency/Keywords.$(OBJEXT) \
+        Concurrency/Waitfor.$(OBJEXT) Common/SemanticError.$(OBJEXT) \
+        Common/UniqueName.$(OBJEXT) Common/DebugMalloc.$(OBJEXT) \
+        Common/Assert.$(OBJEXT) Common/Heap.$(OBJEXT) \
+        Common/Eval.$(OBJEXT) ControlStruct/LabelGenerator.$(OBJEXT) \
+        ControlStruct/LabelFixer.$(OBJEXT) \
+        ControlStruct/MLEMutator.$(OBJEXT) \
+        ControlStruct/Mutate.$(OBJEXT) \
+        ControlStruct/ForExprMutator.$(OBJEXT) \
+        ControlStruct/ExceptTranslate.$(OBJEXT) GenPoly/Box.$(OBJEXT) \
+        GenPoly/GenPoly.$(OBJEXT) GenPoly/ScrubTyVars.$(OBJEXT) \
+        GenPoly/Lvalue.$(OBJEXT) GenPoly/Specialize.$(OBJEXT) \
+        GenPoly/FindFunction.$(OBJEXT) \
+        GenPoly/InstantiateGeneric.$(OBJEXT) \
+        InitTweak/GenInit.$(OBJEXT) InitTweak/FixInit.$(OBJEXT) \
+        InitTweak/FixGlobalInit.$(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) \
+        ResolvExpr/AlternativeFinder.$(OBJEXT) \
+        ResolvExpr/Alternative.$(OBJEXT) ResolvExpr/Unify.$(OBJEXT) \
+        ResolvExpr/PtrsAssignable.$(OBJEXT) \
+        ResolvExpr/CommonType.$(OBJEXT) \
+        ResolvExpr/ConversionCost.$(OBJEXT) \
+        ResolvExpr/CastCost.$(OBJEXT) \
+        ResolvExpr/PtrsCastable.$(OBJEXT) \
+        ResolvExpr/AdjustExprType.$(OBJEXT) \
+        ResolvExpr/AlternativePrinter.$(OBJEXT) \
+        ResolvExpr/Resolver.$(OBJEXT) \
+        ResolvExpr/ResolveTypeof.$(OBJEXT) \
+        ResolvExpr/RenameVars.$(OBJEXT) \
+        ResolvExpr/FindOpenVars.$(OBJEXT) \
+        ResolvExpr/PolyCost.$(OBJEXT) ResolvExpr/Occurs.$(OBJEXT) \
+        ResolvExpr/TypeEnvironment.$(OBJEXT) \
+        ResolvExpr/CurrentObject.$(OBJEXT) \
+        ResolvExpr/ExplodedActual.$(OBJEXT) \
+        ResolvExpr/SpecCost.$(OBJEXT) \
+        ResolvExpr/ResolveAssertions.$(OBJEXT) \
         SymTab/Indexer.$(OBJEXT) SymTab/Mangler.$(OBJEXT) \
+        SymTab/ManglerCommon.$(OBJEXT) SymTab/Validate.$(OBJEXT)
+am__objects_6 = SynTree/Type.$(OBJEXT) SynTree/VoidType.$(OBJEXT) \
+        SymTab/ManglerCommon.$(OBJEXT) SymTab/Validate.$(OBJEXT) \
+        SymTab/FixFunction.$(OBJEXT) SymTab/Autogen.$(OBJEXT) \
+        SynTree/Type.$(OBJEXT) SynTree/VoidType.$(OBJEXT) \
         SynTree/BasicType.$(OBJEXT) SynTree/PointerType.$(OBJEXT) \
         SynTree/ArrayType.$(OBJEXT) SynTree/ReferenceType.$(OBJEXT) \
 …
         SynTree/Initializer.$(OBJEXT) \
         SynTree/TypeSubstitution.$(OBJEXT) SynTree/Attribute.$(OBJEXT) \
+        SynTree/DeclReplacer.$(OBJEXT)
+am__objects_7 = CompilationState.$(OBJEXT) $(am__objects_1) \
+        Concurrency/Keywords.$(OBJEXT) $(am__objects_2) \
+        $(am__objects_3) GenPoly/GenPoly.$(OBJEXT) \
+        GenPoly/Lvalue.$(OBJEXT) InitTweak/GenInit.$(OBJEXT) \
+        InitTweak/InitTweak.$(OBJEXT) Parser/LinkageSpec.$(OBJEXT) \
+        $(am__objects_4) $(am__objects_5) SymTab/Demangle.$(OBJEXT) \
+        $(am__objects_6) Tuples/TupleAssignment.$(OBJEXT) \
+        Tuples/TupleExpansion.$(OBJEXT) Tuples/Explode.$(OBJEXT) \
+        Validate/HandleAttributes.$(OBJEXT) \
+        Validate/FindSpecialDecls.$(OBJEXT)
+am_libdemangle_a_OBJECTS = $(am__objects_7)
+libdemangle_a_OBJECTS = $(am_libdemangle_a_OBJECTS)
+am__installdirs = "$(DESTDIR)$(cfa_cpplibdir)"
+PROGRAMS = $(cfa_cpplib_PROGRAMS)
+am__objects_8 = main.$(OBJEXT) MakeLibCfa.$(OBJEXT) \
+        CompilationState.$(OBJEXT) $(am__objects_1) \
+        CodeGen/Generate.$(OBJEXT) CodeGen/FixNames.$(OBJEXT) \
+        CodeTools/DeclStats.$(OBJEXT) \
+        CodeTools/ResolvProtoDump.$(OBJEXT) \
+        CodeTools/TrackLoc.$(OBJEXT) Concurrency/Keywords.$(OBJEXT) \
+        Concurrency/Waitfor.$(OBJEXT) $(am__objects_2) \
+        Common/DebugMalloc.$(OBJEXT) $(am__objects_3) \
+        ControlStruct/ExceptTranslate.$(OBJEXT) GenPoly/Box.$(OBJEXT) \
+        GenPoly/GenPoly.$(OBJEXT) GenPoly/ScrubTyVars.$(OBJEXT) \
+        GenPoly/Lvalue.$(OBJEXT) GenPoly/Specialize.$(OBJEXT) \
+        GenPoly/FindFunction.$(OBJEXT) \
+        GenPoly/InstantiateGeneric.$(OBJEXT) \
+        InitTweak/GenInit.$(OBJEXT) InitTweak/FixInit.$(OBJEXT) \
+        InitTweak/FixGlobalInit.$(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_4) ResolvExpr/AlternativePrinter.$(OBJEXT) \
+        $(am__objects_5) $(am__objects_6) \
+        SynTree/DeclReplacer.$(OBJEXT) \
         Tuples/TupleAssignment.$(OBJEXT) \
         Tuples/TupleExpansion.$(OBJEXT) Tuples/Explode.$(OBJEXT) \
 …
         Validate/FindSpecialDecls.$(OBJEXT) \
         Virtual/ExpandCasts.$(OBJEXT)
 am____driver_cfa_cpp_OBJECTS = $(am__objects_8)
+am____driver_cfa_cpp_OBJECTS = $(am__objects_1)
 ___driver_cfa_cpp_OBJECTS = $(am____driver_cfa_cpp_OBJECTS)
+am__DEPENDENCIES_1 =
+___driver_cfa_cpp_DEPENDENCIES = $(am__DEPENDENCIES_1) \
+        $(am__DEPENDENCIES_1)
+___driver_cfa_cpp_DEPENDENCIES =
 AM_V_lt = $(am__v_lt_@AM_V@)
 am__v_lt_ = $(am__v_lt_@AM_DEFAULT_V@)
 …
 DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)
 ACLOCAL = @ACLOCAL@
+ALLOCA = @ALLOCA@
 AMTAR = @AMTAR@
 AM_DEFAULT_VERBOSITY = @AM_DEFAULT_VERBOSITY@
 …
 AUTOMAKE_OPTIONS = foreign subdir-objects
 ACLOCAL_AMFLAGS = -I automake
+SRC = main.cc MakeLibCfa.cc CompilationState.cc $(SRC_CODEGEN) \
+        CodeGen/Generate.cc CodeGen/FixNames.cc CodeTools/DeclStats.cc \
+SRC = main.cc MakeLibCfa.cc CompilationState.cc CodeGen/Generate.cc \
+        CodeGen/CodeGenerator.cc CodeGen/GenType.cc \
+        CodeGen/FixNames.cc CodeGen/FixMain.cc \
+        CodeGen/OperatorTable.cc CodeTools/DeclStats.cc \
         CodeTools/ResolvProtoDump.cc CodeTools/TrackLoc.cc \
+        Concurrency/Keywords.cc Concurrency/Waitfor.cc $(SRC_COMMON) \
+        Common/DebugMalloc.cc $(SRC_CONTROLSTRUCT) \
+        Concurrency/Keywords.cc Concurrency/Waitfor.cc \
+        Common/SemanticError.cc Common/UniqueName.cc \
+        Common/DebugMalloc.cc Common/Assert.cc Common/Heap.cc \
+        Common/Eval.cc ControlStruct/LabelGenerator.cc \
+        ControlStruct/LabelFixer.cc ControlStruct/MLEMutator.cc \
+        ControlStruct/Mutate.cc ControlStruct/ForExprMutator.cc \
         ControlStruct/ExceptTranslate.cc GenPoly/Box.cc \
         GenPoly/GenPoly.cc GenPoly/ScrubTyVars.cc GenPoly/Lvalue.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) \
+        Parser/parserutility.cc ResolvExpr/AlternativeFinder.cc \
+        ResolvExpr/Alternative.cc ResolvExpr/Unify.cc \
+        ResolvExpr/PtrsAssignable.cc ResolvExpr/CommonType.cc \
+        ResolvExpr/ConversionCost.cc ResolvExpr/CastCost.cc \
+        ResolvExpr/PtrsCastable.cc ResolvExpr/AdjustExprType.cc \
+        ResolvExpr/AlternativePrinter.cc ResolvExpr/Resolver.cc \
+        ResolvExpr/ResolveTypeof.cc ResolvExpr/RenameVars.cc \
+        ResolvExpr/FindOpenVars.cc ResolvExpr/PolyCost.cc \
+        ResolvExpr/Occurs.cc ResolvExpr/TypeEnvironment.cc \
+        ResolvExpr/CurrentObject.cc ResolvExpr/ExplodedActual.cc \
+        ResolvExpr/SpecCost.cc ResolvExpr/ResolveAssertions.cc \
+        SymTab/Indexer.cc SymTab/Mangler.cc SymTab/ManglerCommon.cc \
+        SymTab/Validate.cc SymTab/FixFunction.cc SymTab/Autogen.cc \
+        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/Statement.cc SynTree/CompoundStmt.cc \
+        SynTree/DeclStmt.cc SynTree/Declaration.cc \
+        SynTree/DeclarationWithType.cc SynTree/ObjectDecl.cc \
+        SynTree/FunctionDecl.cc SynTree/AggregateDecl.cc \
+        SynTree/NamedTypeDecl.cc SynTree/TypeDecl.cc \
+        SynTree/Initializer.cc SynTree/TypeSubstitution.cc \
+        SynTree/Attribute.cc SynTree/DeclReplacer.cc \
         Tuples/TupleAssignment.cc Tuples/TupleExpansion.cc \
         Tuples/Explode.cc Validate/HandleAttributes.cc \
         Validate/FindSpecialDecls.cc Virtual/ExpandCasts.cc
-SRCDEMANGLE = CompilationState.cc $(SRC_CODEGEN) \
-        Concurrency/Keywords.cc $(SRC_COMMON) $(SRC_CONTROLSTRUCT) \
-        GenPoly/GenPoly.cc GenPoly/Lvalue.cc InitTweak/GenInit.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 Validate/HandleAttributes.cc \
-        Validate/FindSpecialDecls.cc
 MAINTAINERCLEANFILES = ${libdir}/${notdir ${cfa_cpplib_PROGRAMS}}
+MOSTLYCLEANFILES = Parser/lex.cc Parser/parser.cc Parser/parser.hh \
+        Parser/parser.output
+@WITH_LIBPROFILER_TRUE@LIBPROFILER = -lprofiler
+@WITH_LIBTCMALLOC_TRUE@LIBTCMALLOC = -ltcmalloc
+@WITH_LIBTCMALLOC_TRUE@TCMALLOCFLAG = -DTCMALLOC
+SRC_CODEGEN = \
+MOSTLYCLEANFILES = Parser/gcc-flags.h Parser/lex.cc Parser/parser.cc \
+        Parser/parser.hh Parser/parser.output
+BUILT_SOURCES = Parser/parser.hh
+AM_YFLAGS = -d -t -v
+# put into lib for now
+cfa_cpplibdir = $(CFA_LIBDIR)
+___driver_cfa_cpp_SOURCES = $(SRC)
+___driver_cfa_cpp_LDADD = -ldl                  # yywrap
+AM_CXXFLAGS = @HOST_FLAGS@ -Wno-deprecated -Wall -Wextra -DDEBUG_ALL -I./Parser -I$(srcdir)/Parser -I$(srcdir)/include -DYY_NO_INPUT -O2 -g -std=c++14
+AM_LDFLAGS = @HOST_FLAGS@ -Xlinker -export-dynamic
+ARFLAGS = cr
+demangler_SOURCES = SymTab/demangler.cc # test driver for the demangler, also useful as a sanity check that libdemangle.a is complete
+demangler_LDADD = libdemangle.a     # yywrap
+noinst_LIBRARIES = libdemangle.a
+libdemangle_a_SOURCES = \
+        SymTab/Demangle.cc \
+        SymTab/ManglerCommon.cc \
+        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/Statement.cc \
+        SynTree/CompoundStmt.cc \
+        SynTree/DeclStmt.cc \
+        SynTree/Declaration.cc \
+        SynTree/DeclarationWithType.cc \
+        SynTree/ObjectDecl.cc \
+        SynTree/FunctionDecl.cc \
+        SynTree/AggregateDecl.cc \
+        SynTree/NamedTypeDecl.cc \
+        SynTree/TypeDecl.cc \
+        SynTree/Initializer.cc \
+        SynTree/TypeSubstitution.cc \
+        SynTree/Attribute.cc \
+        SynTree/DeclReplacer.cc \
+        CompilationState.cc \
         CodeGen/CodeGenerator.cc \
         CodeGen/FixMain.cc \
+        CodeGen/Generate.cc \
         CodeGen/GenType.cc \
+        CodeGen/OperatorTable.cc
+SRC_COMMON = \
+      Common/Assert.cc \
+      Common/Eval.cc \
+      Common/PassVisitor.cc \
+      Common/SemanticError.cc \
+      Common/Stats/Counter.cc \
+      Common/Stats/Heap.cc \
+      Common/Stats/Stats.cc \
+      Common/Stats/Time.cc \
+      Common/UniqueName.cc
+SRC_CONTROLSTRUCT = \
+        CodeGen/OperatorTable.cc \
+        Common/Assert.cc \
+        Common/Eval.cc \
+        Common/SemanticError.cc \
+        Common/UniqueName.cc \
+        Concurrency/Keywords.cc \
         ControlStruct/ForExprMutator.cc \
         ControlStruct/LabelFixer.cc \
         ControlStruct/LabelGenerator.cc \
         ControlStruct/MLEMutator.cc \
+        ControlStruct/Mutate.cc
+BUILT_SOURCES = Parser/parser.hh
+AM_YFLAGS = -d -t -v
+SRC_RESOLVEXPR = \
+      ResolvExpr/AdjustExprType.cc \
+      ResolvExpr/Alternative.cc \
+      ResolvExpr/AlternativeFinder.cc \
+      ResolvExpr/CastCost.cc \
+      ResolvExpr/CommonType.cc \
+      ResolvExpr/ConversionCost.cc \
+      ResolvExpr/CurrentObject.cc \
+      ResolvExpr/ExplodedActual.cc \
+      ResolvExpr/FindOpenVars.cc \
+      ResolvExpr/Occurs.cc \
+      ResolvExpr/PolyCost.cc \
+      ResolvExpr/PtrsAssignable.cc \
+      ResolvExpr/PtrsCastable.cc \
+      ResolvExpr/RenameVars.cc \
+      ResolvExpr/ResolveAssertions.cc \
+      ResolvExpr/Resolver.cc \
+      ResolvExpr/ResolveTypeof.cc \
+      ResolvExpr/SpecCost.cc \
+      ResolvExpr/TypeEnvironment.cc \
+      ResolvExpr/Unify.cc
+SRC_SYMTAB = \
+      SymTab/Autogen.cc \
+      SymTab/FixFunction.cc \
+      SymTab/Indexer.cc \
+      SymTab/Mangler.cc \
+      SymTab/ManglerCommon.cc \
+      SymTab/Validate.cc
+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/Statement.cc \
+      SynTree/CompoundStmt.cc \
+      SynTree/DeclStmt.cc \
+      SynTree/Declaration.cc \
+      SynTree/DeclarationWithType.cc \
+      SynTree/ObjectDecl.cc \
+      SynTree/FunctionDecl.cc \
+      SynTree/AggregateDecl.cc \
+      SynTree/NamedTypeDecl.cc \
+      SynTree/TypeDecl.cc \
+      SynTree/Initializer.cc \
+      SynTree/TypeSubstitution.cc \
+      SynTree/Attribute.cc \
+      SynTree/DeclReplacer.cc
+# put into lib for now
+cfa_cpplibdir = $(CFA_LIBDIR)
+___driver_cfa_cpp_SOURCES = $(SRC)
+___driver_cfa_cpp_LDADD = -ldl $(LIBPROFILER) $(LIBTCMALLOC)
+AM_CXXFLAGS = @HOST_FLAGS@ -Wno-deprecated -Wall -Wextra -DDEBUG_ALL -I./Parser -I$(srcdir)/Parser -I$(srcdir)/include -DYY_NO_INPUT -O3 -g -std=c++14 $(TCMALLOCFLAG)
+AM_LDFLAGS = @HOST_FLAGS@ -Xlinker -export-dynamic
+ARFLAGS = cr
+demangler_SOURCES = SymTab/demangler.cc # test driver for the demangler, also useful as a sanity check that libdemangle.a is complete
+demangler_LDADD = libdemangle.a -ldl                    # yywrap
+noinst_LIBRARIES = libdemangle.a
+libdemangle_a_SOURCES = $(SRCDEMANGLE)
+        ControlStruct/Mutate.cc \
+        GenPoly/GenPoly.cc \
+        GenPoly/Lvalue.cc \
+        InitTweak/GenInit.cc \
+        InitTweak/InitTweak.cc \
+        Parser/LinkageSpec.cc \
+        ResolvExpr/AdjustExprType.cc \
+        ResolvExpr/Alternative.cc \
+        ResolvExpr/AlternativeFinder.cc \
+        ResolvExpr/ExplodedActual.cc \
+        ResolvExpr/CastCost.cc \
+        ResolvExpr/CommonType.cc \
+        ResolvExpr/ConversionCost.cc \
+        ResolvExpr/CurrentObject.cc \
+        ResolvExpr/FindOpenVars.cc \
+        ResolvExpr/Occurs.cc \
+        ResolvExpr/PolyCost.cc \
+        ResolvExpr/PtrsAssignable.cc \
+        ResolvExpr/PtrsCastable.cc \
+        ResolvExpr/RenameVars.cc \
+        ResolvExpr/ResolveAssertions.cc \
+        ResolvExpr/Resolver.cc \
+        ResolvExpr/ResolveTypeof.cc \
+        ResolvExpr/SpecCost.cc \
+        ResolvExpr/TypeEnvironment.cc \
+        ResolvExpr/Unify.cc \
+        SymTab/Autogen.cc \
+        SymTab/FixFunction.cc \
+        SymTab/Indexer.cc \
+        SymTab/Mangler.cc \
+        SymTab/Validate.cc \
+        Tuples/Explode.cc \
+        Tuples/TupleAssignment.cc \
+        Tuples/TupleExpansion.cc \
+        Validate/HandleAttributes.cc \
+        Validate/FindSpecialDecls.cc
 all: $(BUILT_SOURCES)
         $(MAKE) $(AM_MAKEFLAGS) all-am
 …
 clean-noinstLIBRARIES:
         -test -z "$(noinst_LIBRARIES)" || rm -f $(noinst_LIBRARIES)
+SymTab/$(am__dirstamp):
+        @$(MKDIR_P) SymTab
+        @: > SymTab/$(am__dirstamp)
+SymTab/$(DEPDIR)/$(am__dirstamp):
+        @$(MKDIR_P) SymTab/$(DEPDIR)
+        @: > SymTab/$(DEPDIR)/$(am__dirstamp)
+SymTab/Demangle.$(OBJEXT): SymTab/$(am__dirstamp) \
+        SymTab/$(DEPDIR)/$(am__dirstamp)
+SymTab/ManglerCommon.$(OBJEXT): SymTab/$(am__dirstamp) \
+        SymTab/$(DEPDIR)/$(am__dirstamp)
+SynTree/$(am__dirstamp):
+        @$(MKDIR_P) SynTree
+        @: > SynTree/$(am__dirstamp)
+SynTree/$(DEPDIR)/$(am__dirstamp):
+        @$(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/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/DeclReplacer.$(OBJEXT): SynTree/$(am__dirstamp) \
+        SynTree/$(DEPDIR)/$(am__dirstamp)
 CodeGen/$(am__dirstamp):
         @$(MKDIR_P) CodeGen
 …
 CodeGen/FixMain.$(OBJEXT): CodeGen/$(am__dirstamp) \
         CodeGen/$(DEPDIR)/$(am__dirstamp)
+CodeGen/Generate.$(OBJEXT): CodeGen/$(am__dirstamp) \
+        CodeGen/$(DEPDIR)/$(am__dirstamp)
 CodeGen/GenType.$(OBJEXT): CodeGen/$(am__dirstamp) \
         CodeGen/$(DEPDIR)/$(am__dirstamp)
 CodeGen/OperatorTable.$(OBJEXT): CodeGen/$(am__dirstamp) \
         CodeGen/$(DEPDIR)/$(am__dirstamp)
-Concurrency/$(am__dirstamp):
-        @$(MKDIR_P) Concurrency
-        @: > Concurrency/$(am__dirstamp)
-Concurrency/$(DEPDIR)/$(am__dirstamp):
-        @$(MKDIR_P) Concurrency/$(DEPDIR)
-        @: > Concurrency/$(DEPDIR)/$(am__dirstamp)
-Concurrency/Keywords.$(OBJEXT): Concurrency/$(am__dirstamp) \
-        Concurrency/$(DEPDIR)/$(am__dirstamp)
 Common/$(am__dirstamp):
         @$(MKDIR_P) Common
 …
 Common/Eval.$(OBJEXT): Common/$(am__dirstamp) \
         Common/$(DEPDIR)/$(am__dirstamp)
-Common/PassVisitor.$(OBJEXT): Common/$(am__dirstamp) \
-        Common/$(DEPDIR)/$(am__dirstamp)
 Common/SemanticError.$(OBJEXT): Common/$(am__dirstamp) \
         Common/$(DEPDIR)/$(am__dirstamp)
-Common/Stats/$(am__dirstamp):
-        @$(MKDIR_P) Common/Stats
-        @: > Common/Stats/$(am__dirstamp)
-Common/Stats/$(DEPDIR)/$(am__dirstamp):
-        @$(MKDIR_P) Common/Stats/$(DEPDIR)
-        @: > Common/Stats/$(DEPDIR)/$(am__dirstamp)
-Common/Stats/Counter.$(OBJEXT): Common/Stats/$(am__dirstamp) \
-        Common/Stats/$(DEPDIR)/$(am__dirstamp)
-Common/Stats/Heap.$(OBJEXT): Common/Stats/$(am__dirstamp) \
-        Common/Stats/$(DEPDIR)/$(am__dirstamp)
-Common/Stats/Stats.$(OBJEXT): Common/Stats/$(am__dirstamp) \
-        Common/Stats/$(DEPDIR)/$(am__dirstamp)
-Common/Stats/Time.$(OBJEXT): Common/Stats/$(am__dirstamp) \
-        Common/Stats/$(DEPDIR)/$(am__dirstamp)
 Common/UniqueName.$(OBJEXT): Common/$(am__dirstamp) \
         Common/$(DEPDIR)/$(am__dirstamp)
+Concurrency/$(am__dirstamp):
+        @$(MKDIR_P) Concurrency
+        @: > Concurrency/$(am__dirstamp)
+Concurrency/$(DEPDIR)/$(am__dirstamp):
+        @$(MKDIR_P) Concurrency/$(DEPDIR)
+        @: > Concurrency/$(DEPDIR)/$(am__dirstamp)
+Concurrency/Keywords.$(OBJEXT): Concurrency/$(am__dirstamp) \
+        Concurrency/$(DEPDIR)/$(am__dirstamp)
 ControlStruct/$(am__dirstamp):
         @$(MKDIR_P) ControlStruct
 …
 ResolvExpr/AlternativeFinder.$(OBJEXT): ResolvExpr/$(am__dirstamp) \
         ResolvExpr/$(DEPDIR)/$(am__dirstamp)
+ResolvExpr/ExplodedActual.$(OBJEXT): ResolvExpr/$(am__dirstamp) \
+        ResolvExpr/$(DEPDIR)/$(am__dirstamp)
 ResolvExpr/CastCost.$(OBJEXT): ResolvExpr/$(am__dirstamp) \
         ResolvExpr/$(DEPDIR)/$(am__dirstamp)
 …
 ResolvExpr/CurrentObject.$(OBJEXT): ResolvExpr/$(am__dirstamp) \
         ResolvExpr/$(DEPDIR)/$(am__dirstamp)
-ResolvExpr/ExplodedActual.$(OBJEXT): ResolvExpr/$(am__dirstamp) \
-        ResolvExpr/$(DEPDIR)/$(am__dirstamp)
 ResolvExpr/FindOpenVars.$(OBJEXT): ResolvExpr/$(am__dirstamp) \
         ResolvExpr/$(DEPDIR)/$(am__dirstamp)
 …
 ResolvExpr/Unify.$(OBJEXT): ResolvExpr/$(am__dirstamp) \
         ResolvExpr/$(DEPDIR)/$(am__dirstamp)
-SymTab/$(am__dirstamp):
-        @$(MKDIR_P) SymTab
-        @: > SymTab/$(am__dirstamp)
-SymTab/$(DEPDIR)/$(am__dirstamp):
-        @$(MKDIR_P) SymTab/$(DEPDIR)
-        @: > SymTab/$(DEPDIR)/$(am__dirstamp)
 SymTab/Autogen.$(OBJEXT): SymTab/$(am__dirstamp) \
         SymTab/$(DEPDIR)/$(am__dirstamp)
 …
 SymTab/Mangler.$(OBJEXT): SymTab/$(am__dirstamp) \
         SymTab/$(DEPDIR)/$(am__dirstamp)
-SymTab/ManglerCommon.$(OBJEXT): SymTab/$(am__dirstamp) \
-        SymTab/$(DEPDIR)/$(am__dirstamp)
 SymTab/Validate.$(OBJEXT): SymTab/$(am__dirstamp) \
         SymTab/$(DEPDIR)/$(am__dirstamp)
-SymTab/Demangle.$(OBJEXT): SymTab/$(am__dirstamp) \
-        SymTab/$(DEPDIR)/$(am__dirstamp)
-SynTree/$(am__dirstamp):
-        @$(MKDIR_P) SynTree
-        @: > SynTree/$(am__dirstamp)
-SynTree/$(DEPDIR)/$(am__dirstamp):
-        @$(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/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/DeclReplacer.$(OBJEXT): SynTree/$(am__dirstamp) \
-        SynTree/$(DEPDIR)/$(am__dirstamp)
 Tuples/$(am__dirstamp):
         @$(MKDIR_P) Tuples
 …
         @$(MKDIR_P) Tuples/$(DEPDIR)
         @: > Tuples/$(DEPDIR)/$(am__dirstamp)
+Tuples/Explode.$(OBJEXT): Tuples/$(am__dirstamp) \
+        Tuples/$(DEPDIR)/$(am__dirstamp)
 Tuples/TupleAssignment.$(OBJEXT): Tuples/$(am__dirstamp) \
         Tuples/$(DEPDIR)/$(am__dirstamp)
 Tuples/TupleExpansion.$(OBJEXT): Tuples/$(am__dirstamp) \
-        Tuples/$(DEPDIR)/$(am__dirstamp)
-Tuples/Explode.$(OBJEXT): Tuples/$(am__dirstamp) \
         Tuples/$(DEPDIR)/$(am__dirstamp)
 Validate/$(am__dirstamp):
 …
         echo " rm -f" $$list; \
         rm -f $$list
-CodeGen/Generate.$(OBJEXT): CodeGen/$(am__dirstamp) \
-        CodeGen/$(DEPDIR)/$(am__dirstamp)
 CodeGen/FixNames.$(OBJEXT): CodeGen/$(am__dirstamp) \
         CodeGen/$(DEPDIR)/$(am__dirstamp)
 …
         Concurrency/$(DEPDIR)/$(am__dirstamp)
 Common/DebugMalloc.$(OBJEXT): Common/$(am__dirstamp) \
+        Common/$(DEPDIR)/$(am__dirstamp)
+Common/Heap.$(OBJEXT): Common/$(am__dirstamp) \
         Common/$(DEPDIR)/$(am__dirstamp)
 ControlStruct/ExceptTranslate.$(OBJEXT):  \
 …
         -rm -f CodeTools/*.$(OBJEXT)
         -rm -f Common/*.$(OBJEXT)
-        -rm -f Common/Stats/*.$(OBJEXT)
         -rm -f Concurrency/*.$(OBJEXT)
         -rm -f ControlStruct/*.$(OBJEXT)
 …
 @AMDEP_TRUE@@am__include@ @am__quote@Common/$(DEPDIR)/DebugMalloc.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@Common/$(DEPDIR)/Eval.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@Common/$(DEPDIR)/PassVisitor.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@Common/$(DEPDIR)/Heap.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@Common/$(DEPDIR)/SemanticError.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@Common/$(DEPDIR)/UniqueName.Po@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@Common/Stats/$(DEPDIR)/Counter.Po@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@Common/Stats/$(DEPDIR)/Heap.Po@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@Common/Stats/$(DEPDIR)/Stats.Po@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@Common/Stats/$(DEPDIR)/Time.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@Concurrency/$(DEPDIR)/Keywords.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@Concurrency/$(DEPDIR)/Waitfor.Po@am__quote@
 …
         -rm -f Common/$(DEPDIR)/$(am__dirstamp)
         -rm -f Common/$(am__dirstamp)
-        -rm -f Common/Stats/$(DEPDIR)/$(am__dirstamp)
-        -rm -f Common/Stats/$(am__dirstamp)
         -rm -f Concurrency/$(DEPDIR)/$(am__dirstamp)
         -rm -f Concurrency/$(am__dirstamp)
 …
 distclean: distclean-am
         -rm -rf ./$(DEPDIR) CodeGen/$(DEPDIR) CodeTools/$(DEPDIR) Common/$(DEPDIR) Common/Stats/$(DEPDIR) Concurrency/$(DEPDIR) ControlStruct/$(DEPDIR) GenPoly/$(DEPDIR) InitTweak/$(DEPDIR) Parser/$(DEPDIR) ResolvExpr/$(DEPDIR) SymTab/$(DEPDIR) SynTree/$(DEPDIR) Tuples/$(DEPDIR) Validate/$(DEPDIR) Virtual/$(DEPDIR)
+        -rm -rf ./$(DEPDIR) CodeGen/$(DEPDIR) CodeTools/$(DEPDIR) Common/$(DEPDIR) Concurrency/$(DEPDIR) ControlStruct/$(DEPDIR) GenPoly/$(DEPDIR) InitTweak/$(DEPDIR) Parser/$(DEPDIR) ResolvExpr/$(DEPDIR) SymTab/$(DEPDIR) SynTree/$(DEPDIR) Tuples/$(DEPDIR) Validate/$(DEPDIR) Virtual/$(DEPDIR)
         -rm -f Makefile
 distclean-am: clean-am distclean-compile distclean-generic \
 …
 maintainer-clean: maintainer-clean-am
         -rm -rf ./$(DEPDIR) CodeGen/$(DEPDIR) CodeTools/$(DEPDIR) Common/$(DEPDIR) Common/Stats/$(DEPDIR) Concurrency/$(DEPDIR) ControlStruct/$(DEPDIR) GenPoly/$(DEPDIR) InitTweak/$(DEPDIR) Parser/$(DEPDIR) ResolvExpr/$(DEPDIR) SymTab/$(DEPDIR) SynTree/$(DEPDIR) Tuples/$(DEPDIR) Validate/$(DEPDIR) Virtual/$(DEPDIR)
+        -rm -rf ./$(DEPDIR) CodeGen/$(DEPDIR) CodeTools/$(DEPDIR) Common/$(DEPDIR) Concurrency/$(DEPDIR) ControlStruct/$(DEPDIR) GenPoly/$(DEPDIR) InitTweak/$(DEPDIR) Parser/$(DEPDIR) ResolvExpr/$(DEPDIR) SymTab/$(DEPDIR) SynTree/$(DEPDIR) Tuples/$(DEPDIR) Validate/$(DEPDIR) Virtual/$(DEPDIR)
         -rm -f Makefile
 maintainer-clean-am: distclean-am maintainer-clean-generic
 …
+$(addprefix $(srcdir)/, ResolvExpr/ConversionCost.cc ResolvExpr/CommonType.cc SymTab/ManglerCommon.cc) : $(srcdir)/SynTree/Type.h
+$(srcdir)/SynTree/Type.h : BasicTypes-gen.cc
+        ${AM_V_GEN}${CXXCOMPILE} $< -o BasicTypes-gen -Wall -Wextra
+        @./BasicTypes-gen
+        @rm BasicTypes-gen
+Parser/gcc-flags.h :
+        ${AM_V_GEN}$(CC) -dM -E - < /dev/null | sed 's/define /define __GCC__/' > $(@)
+Parser/lex.ll : Parser/gcc-flags.h
 # Tell versions [3.59,3.63) of GNU make to not export all variables.

src/Parser/DeclarationNode.cc

-              r933f32f
+              r6a9d4b4
 // Created On       : Sat May 16 12:34:05 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Feb  1 16:49:17 2019
 // Update Count     : 1113
+// Last Modified On : Thu Nov  1 20:54:26 2018
+// Update Count     : 1108
 //
 …
 // These must harmonize with the corresponding DeclarationNode enumerations.
+const char * DeclarationNode::basicTypeNames[] = { "void", "_Bool", "char", "int", "int128",
+                                                                                                   "float", "double", "long double", "float80", "float128",
+                                                                                                   "_float16", "_float32", "_float32x", "_float64", "_float64x", "_float128", "_float128x", "NoBasicTypeNames" };
+const char * DeclarationNode::complexTypeNames[] = { "_Complex", "NoComplexTypeNames", "_Imaginary" }; // Imaginary unsupported => parse, but make invisible and print error message
+const char * DeclarationNode::basicTypeNames[] = { "void", "_Bool", "char", "int", "float", "double", "long double", "int128", "float80", "float128", "NoBasicTypeNames" };
+const char * DeclarationNode::complexTypeNames[] = { "_Complex", "_Imaginary", "NoComplexTypeNames" };
 const char * DeclarationNode::signednessNames[] = { "signed", "unsigned", "NoSignednessNames" };
 const char * DeclarationNode::lengthNames[] = { "short", "long", "long long", "NoLengthNames" };

src/Parser/ExpressionNode.cc

-              r933f32f
+              r6a9d4b4
 // Created On       : Sat May 16 13:17:07 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sun Mar 10 16:10:32 2019
 // Update Count     : 976
+// Last Modified On : Mon Jun  4 21:24:45 2018
+// Update Count     : 802
 //
 …
 extern const Type::Qualifiers noQualifiers;                             // no qualifiers on constants
+// static inline bool checkH( char c ) { return c == 'h' || c == 'H'; }
+// static inline bool checkZ( char c ) { return c == 'z' || c == 'Z'; }
+// static inline bool checkU( char c ) { return c == 'u' || c == 'U'; }
+static inline bool checkH( char c ) { return c == 'h' || c == 'H'; }
+static inline bool checkL( char c ) { return c == 'l' || c == 'L'; }
+static inline bool checkZ( char c ) { return c == 'z' || c == 'Z'; }
+static inline bool checkU( char c ) { return c == 'u' || c == 'U'; }
 static inline bool checkF( char c ) { return c == 'f' || c == 'F'; }
 static inline bool checkD( char c ) { return c == 'd' || c == 'D'; }
-static inline bool checkF80( char c ) { return c == 'w' || c == 'W'; }
-static inline bool checkF128( char c ) { return c == 'q' || c == 'Q'; }
-static inline bool checkL( char c ) { return c == 'l' || c == 'L'; }
 static inline bool checkI( char c ) { return c == 'i' || c == 'I'; }
 static inline bool checkB( char c ) { return c == 'b' || c == 'B'; }
 static inline bool checkX( char c ) { return c == 'x' || c == 'X'; }
+// static inline bool checkN( char c ) { return c == 'n' || c == 'N'; }
+void lnthSuffix( string & str, int & type, int & ltype ) {
+        string::size_type posn = str.find_last_of( "lL" );
+        if ( posn == string::npos ) return;                                     // no suffix
+        if ( posn == str.length() - 1 ) { type = 3; return; } // no length => long
+        string::size_type next = posn + 1;                                      // advance to length
+        if ( str[next] == '3' ) {                                                       // 32
+                type = ltype = 2;
+        } else if ( str[next] == '6' ) {                                        // 64
+                type = ltype = 3;
+        } else if ( str[next] == '8' ) {                                        // 8
+                type = ltype = 1;
+        } else if ( str[next] == '1' ) {
+                if ( str[next + 1] == '6' ) {                                   // 16
+                        type = ltype = 0;
+static const char * lnthsInt[2][6] = {
+        { "int8_t", "int16_t", "int32_t", "int64_t", "size_t", },
+        { "uint8_t", "uint16_t", "uint32_t", "uint64_t", "size_t", }
+}; // lnthsInt
+static inline void checkLNInt( string & str, int & lnth, int & size ) {
+        string::size_type posn = str.find_first_of( "lL" ), start = posn;
+  if ( posn == string::npos ) return;
+        size = 4;                                                                                       // assume largest size
+        posn += 1;                                                                                      // advance to size
+        if ( str[posn] == '8' ) {                                                       // 8
+                lnth = 0;
+        } else if ( str[posn] == '1' ) {
+                posn += 1;
+                if ( str[posn] == '6' ) {                                               // 16
+                        lnth = 1;
                 } else {                                                                                // 128
+                        type = 5; ltype = 6;
+                } // if
+        } // if
+        // remove "lL" for these cases because it may not imply long
+        str.erase( posn );                                                                      // remove length
+} // lnthSuffix
+void valueToType( unsigned long long int & v, bool dec, int & type, bool & Unsigned ) {
+        // use value to determine type
+        if ( v <= INT_MAX ) {                                                           // signed int
+                type = 2;
+        } else if ( v <= UINT_MAX && ! dec ) {                          // unsigned int
+                type = 2;
+                Unsigned = true;                                                                // unsigned
+        } else if ( v <= LONG_MAX ) {                                           // signed long int
+                type = 3;
+        } else if ( v <= ULONG_MAX && ( ! dec || LONG_MAX == LLONG_MAX ) ) { // signed long int
+                type = 3;
+                Unsigned = true;                                                                // unsigned long int
+        } else if ( v <= LLONG_MAX ) {                                          // signed long long int
+                type = 4;
+        } else {                                                                                        // unsigned long long int
+                type = 4;
+                Unsigned = true;                                                                // unsigned long long int
+        } // if
+} // valueToType
+                        posn += 1;
+                        lnth = 5;
+                } // if
+        } else {
+                if ( str[posn] == '3' ) {                                               // 32
+                        lnth = 2;
+                } else if ( str[posn] == '6' ) {                                // 64
+                        lnth = 3;
+                } else {
+                        assertf( false, "internal error, bad integral length %s", str.c_str() );
+                } // if
+                posn += 1;
+        } // if
+        str.erase( start, posn - start + 1 );                           // remove length suffix
+} // checkLNInt
 Expression * build_constantInteger( string & str ) {
         static const BasicType::Kind kind[2][7] = {
                 // short (h) must be before char (hh) because shorter type has the longer suffix
+        static const BasicType::Kind kind[2][6] = {
+                // short (h) must be before char (hh)
                 { BasicType::ShortSignedInt, BasicType::SignedChar, BasicType::SignedInt, BasicType::LongSignedInt, BasicType::LongLongSignedInt, BasicType::SignedInt128, },
                 { BasicType::ShortUnsignedInt, BasicType::UnsignedChar, BasicType::UnsignedInt, BasicType::LongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::UnsignedInt128, },
         };
+        static const char * lnthsInt[2][6] = {
+                { "int16_t",  "int8_t",  "int32_t",  "int64_t",  "size_t",  "uintptr_t", },
+                { "uint16_t", "uint8_t", "uint32_t", "uint64_t", "size_t",  "uintptr_t", },
+        }; // lnthsInt
+        bool dec = true, Unsigned = false;                                      // decimal, unsigned constant
+        int size;                                                                                       // 0 => short, 1 => char, 2 => int, 3 => long int, 4 => long long int, 5 => int128
+        int lnth = -1;                                                                          // literal length
         unsigned long long int v;                                                       // converted integral value
         size_t last = str.length() - 1;                                         // last subscript of constant
         Expression * ret;
-        //string fred( str );
-        int type = -1;                                                                          // 0 => short, 1 => char, 2 => int, 3 => long int, 4 => long long int, 5 => int128
-        int ltype = -1;                                                                         // 0 => 16 bits, 1 => 8 bits, 2 => 32 bits, 3 => 64 bits, 4 => size_t, 5 => intptr, 6 => pointer
-        bool dec = true, Unsigned = false;                                      // decimal, unsigned constant
         // special constants
 …
         } // if
         // Cannot be just "0"/"1"; sscanf stops at the suffix, if any; value goes over the wall => always generate
+        // Cannot be "0"
         if ( str[0] == '0' ) {                                                          // radix character ?
 …
                         //printf( "%llx %llu\n", v, v );
                 } else if ( checkB( str[1] ) ) {                                // binary constant ?
                         v = 0;                                                                          // compute value
                         for ( unsigned int i = 2;; ) {                          // ignore prefix
+                        v = 0;
+                        for ( unsigned int i = 2;; i += 1 ) {           // compute value
                                 if ( str[i] == '1' ) v |= 1;
+                                i += 1;
+                          if ( i == last - 1 || (str[i] != '0' && str[i] != '1') ) break;
+                          if ( i == last ) break;
                                 v <<= 1;
                         } // for
                         //printf( "%#llx %llu\n", v, v );
+                        //printf( "%llx %llu\n", v, v );
                 } else {                                                                                // octal constant
                         sscanf( (char *)str.c_str(), "%llo", &v );
                         //printf( "%#llo %llu\n", v, v );
+                        //printf( "%llo %llu\n", v, v );
                 } // if
         } else {                                                                                        // decimal constant ?
                 sscanf( (char *)str.c_str(), "%llu", &v );
+                //printf( "%llu\n", v );
+        } // if
+        string::size_type posn;
+        if ( isdigit( str[last] ) ) {                                           // no suffix ?
+                lnthSuffix( str, type, ltype );                                 // could have length suffix
+                if ( type == -1 ) {                                                             // no suffix
+                        valueToType( v, dec, type, Unsigned );
+                } // if
+        } else {
+                // At least one digit in integer constant, so safe to backup while looking for suffix.
+                posn = str.find_last_of( "pP" );
+                if ( posn != string::npos ) { valueToType( v, dec, type, Unsigned ); ltype = 5; str.erase( posn, 1 ); goto FINI; }
+                posn = str.find_last_of( "zZ" );
+                if ( posn != string::npos ) { Unsigned = true; type = 2; ltype = 4; str.erase( posn, 1 ); goto FINI; }
+                // 'u' can appear before or after length suffix
+                if ( str.find_last_of( "uU" ) != string::npos ) Unsigned = true;
+                posn = str.rfind( "hh" );
+                if ( posn != string::npos ) { type = 1; str.erase( posn, 2 ); goto FINI; }
+                posn = str.rfind( "HH" );
+                if ( posn != string::npos ) { type = 1; str.erase( posn, 2 ); goto FINI; }
+                posn = str.find_last_of( "hH" );
+                if ( posn != string::npos ) { type = 0; str.erase( posn, 1 ); goto FINI; }
+                posn = str.find_last_of( "nN" );
+                if ( posn != string::npos ) { type = 2; str.erase( posn, 1 ); goto FINI; }
+                if ( str.rfind( "ll" ) != string::npos || str.rfind( "LL" ) != string::npos ) { type = 4; goto FINI; }
+                lnthSuffix( str, type, ltype );                                 // must be after check for "ll"
+                if ( type == -1 ) {                                                             // only 'u' suffix ?
+                        valueToType( v, dec, type, Unsigned );
+                } // if
+          FINI: ;
+        } // if
+        //if ( !( 0 <= type && type <= 6 ) ) { printf( "%s %lu %d %s\n", fred.c_str(), fred.length(), type, str.c_str() ); }
+        assert( 0 <= type && type <= 6 );
+                //printf( "%llu %llu\n", v, v );
+        } // if
+        if ( v <= INT_MAX ) {                                                           // signed int
+                size = 2;
+        } else if ( v <= UINT_MAX && ! dec ) {                          // unsigned int
+                size = 2;
+                Unsigned = true;                                                                // unsigned
+        } else if ( v <= LONG_MAX ) {                                           // signed long int
+                size = 3;
+        } else if ( v <= ULONG_MAX && ( ! dec || LONG_MAX == LLONG_MAX ) ) { // signed long int
+                size = 3;
+                Unsigned = true;                                                                // unsigned long int
+        } else if ( v <= LLONG_MAX ) {                                          // signed long long int
+                size = 4;
+        } else {                                                                                        // unsigned long long int
+                size = 4;
+                Unsigned = true;                                                                // unsigned long long int
+        } // if
+        // At least one digit in integer constant, so safe to backup while looking for suffix.
+        if ( checkU( str[last] ) ) {                                            // suffix 'u' ?
+                Unsigned = true;
+                if ( checkL( str[last - 1] ) ) {                                // suffix 'l' ?
+                        size = 3;
+                        if ( checkL( str[last - 2] ) ) {                        // suffix "ll" ?
+                                size = 4;
+                        } // if
+                } else if ( checkH( str[last - 1] ) ) {                 // suffix 'h' ?
+                        size = 0;
+                        if ( checkH( str[last - 2] ) ) {                        // suffix "hh" ?
+                                size = 1;
+                        } // if
+                        str.erase( last - size - 1, size + 1 );         // remove 'h'/"hh"
+                } else {                                                                                // suffix "ln" ?
+                        checkLNInt( str, lnth, size );
+                } // if
+        } else if ( checkL( str[ last ] ) ) {                           // suffix 'l' ?
+                size = 3;
+                if ( checkL( str[last - 1] ) ) {                                // suffix 'll' ?
+                        size = 4;
+                        if ( checkU( str[last - 2] ) ) {                        // suffix 'u' ?
+                                Unsigned = true;
+                        } // if
+                } else if ( checkU( str[last - 1] ) ) {                 // suffix 'u' ?
+                        Unsigned = true;
+                } // if
+        } else if ( checkH( str[ last ] ) ) {                           // suffix 'h' ?
+                size = 0;
+                if ( checkH( str[last - 1] ) ) {                                // suffix "hh" ?
+                        size = 1;
+                        if ( checkU( str[last - 2] ) ) {                        // suffix 'u' ?
+                                Unsigned = true;
+                        } // if
+                } else if ( checkU( str[last - 1] ) ) {                 // suffix 'u' ?
+                        Unsigned = true;
+                } // if
+                str.erase( last - size, size + 1 );                             // remove 'h'/"hh"
+        } else if ( checkZ( str[last] ) ) {                                     // suffix 'z' ?
+                lnth = 4;
+                str.erase( last, 1 );                                                   // remove 'z'
+        } else {                                                                                        // suffix "ln" ?
+                checkLNInt( str, lnth, size );
+        } // if
+        assert( 0 <= size && size < 6 );
         // Constant type is correct for overload resolving.
         ret = new ConstantExpr( Constant( new BasicType( noQualifiers, kind[Unsigned][type] ), str, v ) );
         if ( Unsigned && type < 2 ) {                                           // hh or h, less than int ?
+        ret = new ConstantExpr( Constant( new BasicType( noQualifiers, kind[Unsigned][size] ), str, v ) );
+        if ( Unsigned && size < 2 ) {                                           // hh or h, less than int ?
                 // int i = -1uh => 65535 not -1, so cast is necessary for unsigned, which unfortunately eliminates warnings for large values.
+                ret = new CastExpr( ret, new BasicType( Type::Qualifiers(), kind[Unsigned][type] ), false );
+        } else if ( ltype != -1 ) {                                                     // explicit length ?
+                if ( ltype == 6 ) {                                                             // int128, (int128)constant
+                        ret = new CastExpr( ret, new BasicType( Type::Qualifiers(), kind[Unsigned][type] ), false );
+                } else {                                                                                // explicit length, (length_type)constant
+                        ret = new CastExpr( ret, new TypeInstType( Type::Qualifiers(), lnthsInt[Unsigned][ltype], false ), false );
+                        if ( ltype == 5 ) {                                                     // pointer, intptr( (uintptr_t)constant )
+                                ret = build_func( new ExpressionNode( build_varref( new string( "intptr" ) ) ), new ExpressionNode( ret ) );
+                        } // if
+                } // if
+        } // if
+  CLEANUP: ;
+                ret = new CastExpr( ret, new BasicType( Type::Qualifiers(), kind[Unsigned][size] ), false );
+        } else if ( lnth != -1 ) {                                                      // explicit length ?
+                if ( lnth == 5 ) {                                                              // int128 ?
+                        size = 5;
+                        ret = new CastExpr( ret, new BasicType( Type::Qualifiers(), kind[Unsigned][size] ), false );
+                } else {
+                        ret = new CastExpr( ret, new TypeInstType( Type::Qualifiers(), lnthsInt[Unsigned][lnth], false ), false );
+                } // if
+        } // if
+  CLEANUP:
         delete &str;                                                                            // created by lex
         return ret;
 …
+static inline void checkFnxFloat( string & str, size_t last, bool & explnth, int & type ) {
+        string::size_type posn;
+        // floating-point constant has minimum of 2 characters, 1. or .1, so safe to look ahead
+        if ( str[1] == 'x' ) {                                                          // hex ?
+                posn = str.find_last_of( "pP" );                                // back for exponent (must have)
+                posn = str.find_first_of( "fF", posn + 1 );             // forward for size (fF allowed in hex constant)
+        } else {
+                posn = str.find_last_of( "fF" );                                // back for size (fF not allowed)
+        } // if
+static inline void checkLNFloat( string & str, int & lnth, int & size ) {
+        string::size_type posn = str.find_first_of( "lL" ), start = posn;
   if ( posn == string::npos ) return;
+        explnth = true;
+        size = 2;                                                                                       // assume largest size
+        lnth = 0;
         posn += 1;                                                                                      // advance to size
         if ( str[posn] == '3' ) {                                                       // 32
+                if ( str[last] != 'x' ) type = 6;
+                else type = 7;
+                size = 0;
         } else if ( str[posn] == '6' ) {                                        // 64
+                if ( str[last] != 'x' ) type = 8;
+                else type = 9;
+        } else if ( str[posn] == '8' ) {                                        // 80
+                type = 3;
+        } else if ( str[posn] == '1' ) {                                        // 16/128
+                if ( str[posn + 1] == '6' ) {                                   // 16
+                        type = 5;
+                } else {                                                                                // 128
+                        if ( str[last] != 'x' ) type = 10;
+                        else type = 11;
+                } // if
+                size = 1;
+        } else if ( str[posn] == '8' || str[posn] == '1' ) { // 80, 128
+                size = 2;
+                if ( str[posn] == '1' ) posn += 1;
         } else {
                 assertf( false, "internal error, bad floating point length %s", str.c_str() );
         } // if
+} // checkFnxFloat
+        posn += 1;
+        str.erase( start, posn - start + 1 );                           // remove length suffix
+} // checkLNFloat
 Expression * build_constantFloat( string & str ) {
         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::Kind)-1, (BasicType::Kind)-1, BasicType::uFloat16Complex, BasicType::uFloat32Complex, BasicType::uFloat32xComplex, BasicType::uFloat64Complex, BasicType::uFloat64xComplex, BasicType::uFloat128Complex, BasicType::uFloat128xComplex },
+        static const BasicType::Kind kind[2][3] = {
+                { BasicType::Float, BasicType::Double, BasicType::LongDouble },
+                { BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex },
         };
+        // floating-point constant has minimum of 2 characters 1. or .1
+        bool complx = false;                                                            // real, complex
+        int size = 1;                                                                           // 0 => float, 1 => double, 2 => long double
+        int lnth = -1;                                                                          // literal length
+        // floating-point constant has minimum of 2 characters: 1. or .1
         size_t last = str.length() - 1;
         double v;
-        int type;                                                                                       // 0 => float, 1 => double, 3 => long double, ...
-        bool complx = false;                                                            // real, complex
-        bool explnth = false;                                                           // explicit literal length
         sscanf( str.c_str(), "%lg", &v );
 …
         if ( checkF( str[last] ) ) {                                            // float ?
                 type = 0;
+                size = 0;
         } else if ( checkD( str[last] ) ) {                                     // double ?
                 type = 1;
+                size = 1;
         } else if ( checkL( str[last] ) ) {                                     // long double ?
+                type = 2;
+        } else if ( checkF80( str[last] ) ) {                           // __float80 ?
+                type = 3;
+        } else if ( checkF128( str[last] ) ) {                          // __float128 ?
+                type = 4;
+                size = 2;
         } else {
+                type = 1;                                                                               // double (default if no suffix)
+                checkFnxFloat( str, last, explnth, type );
+        } // if
+                size = 1;                                                                               // double (default)
+                checkLNFloat( str, lnth, size );
+        } // if
         if ( ! complx && checkI( str[last - 1] ) ) {            // imaginary ?
                 complx = true;
         } // if
         assert( 0 <= type && type < 12 );
         Expression * ret = new ConstantExpr( Constant( new BasicType( noQualifiers, kind[complx][type] ), str, v ) );
         if ( explnth ) {                                                                        // explicit length ?
                 ret = new CastExpr( ret, new BasicType( Type::Qualifiers(), kind[complx][type] ), false );
+        assert( 0 <= size && size < 3 );
+        Expression * ret = new ConstantExpr( Constant( new BasicType( noQualifiers, kind[complx][size] ), str, v ) );
+        if ( lnth != -1 ) {                                                                     // explicit length ?
+                ret = new CastExpr( ret, new BasicType( Type::Qualifiers(), kind[complx][size] ), false );
         } // if

src/Parser/ParseNode.h

-              r933f32f
+              r6a9d4b4
 // Created On       : Sat May 16 13:28:16 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Mon Apr 15 14:22:39 2019
 // Update Count     : 874
+// Last Modified On : Thu Nov  1 20:54:53 2018
+// Update Count     : 854
 //
 …
         void printOneLine( __attribute__((unused)) std::ostream & os, __attribute__((unused)) int indent = 0 ) const {}
+        Expression *get_expr() const { return expr.get(); }
         template<typename T>
         bool isExpressionType() const { return nullptr != dynamic_cast<T>(expr.get()); }
         Expression * build() const { return const_cast<ExpressionNode *>(this)->expr.release(); }
-        std::unique_ptr<Expression> expr;                                       // public because of lifetime implications
   private:
         bool extension = false;
+        std::unique_ptr<Expression> expr;
 }; // ExpressionNode
 …
 class DeclarationNode : public ParseNode {
   public:
+        // These enumerations must harmonize with their names in DeclarationNode.cc.
+        enum BasicType { Void, Bool, Char, Int, Int128,
+                                         Float, Double, LongDouble, uuFloat80, uuFloat128,
+                                         uFloat16, uFloat32, uFloat32x, uFloat64, uFloat64x, uFloat128, uFloat128x, NoBasicType };
+        // These enumerations must harmonize with their names.
+        enum BasicType { Void, Bool, Char, Int, Float, Double, LongDouble, Int128, Float80, Float128, NoBasicType };
         static const char * basicTypeNames[];
         enum ComplexType { Complex, NoComplexType, Imaginary }; // Imaginary unsupported => parse, but make invisible and print error message
+        enum ComplexType { Complex, Imaginary, NoComplexType };
         static const char * complexTypeNames[];
         enum Signedness { Signed, Unsigned, NoSignedness };

src/Parser/TypeData.cc

-              r933f32f
+              r6a9d4b4
 // Created On       : Sat May 16 15:12:51 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed Feb 13 18:16:23 2019
 // Update Count     : 649
+// Last Modified On : Fri Nov  2 07:54:26 2018
+// Update Count     : 624
 //
 …
           case DeclarationNode::Float:
+          case DeclarationNode::Float80:
+          case DeclarationNode::Float128:
           case DeclarationNode::Double:
           case DeclarationNode::LongDouble:                                     // not set until below
+          case DeclarationNode::uuFloat80:
+          case DeclarationNode::uuFloat128:
+          case DeclarationNode::uFloat16:
+          case DeclarationNode::uFloat32:
+          case DeclarationNode::uFloat32x:
+          case DeclarationNode::uFloat64:
+          case DeclarationNode::uFloat64x:
+          case DeclarationNode::uFloat128:
+          case DeclarationNode::uFloat128x:
+                static BasicType::Kind floattype[2][12] = {
+                        { 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, },
+                        { BasicType::Float, BasicType::Double, BasicType::LongDouble, BasicType::uuFloat80, BasicType::uuFloat128, BasicType::uFloat16, BasicType::uFloat32, BasicType::uFloat32x, BasicType::uFloat64, BasicType::uFloat64x, BasicType::uFloat128, BasicType::uFloat128x, },
+                static BasicType::Kind floattype[3][3] = {
+                        { BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex },
+                        { BasicType::FloatImaginary, BasicType::DoubleImaginary, BasicType::LongDoubleImaginary },
+                        { BasicType::Float, BasicType::Double, BasicType::LongDouble },
                 };
 …
                         genTSError( DeclarationNode::lengthNames[ td->length ], td->basictype );
                 } // if
-                if ( td->complextype == DeclarationNode::Imaginary ) {
-                        genTSError( DeclarationNode::complexTypeNames[ td->complextype ], td->basictype );
-                } // if
-                if ( (td->basictype == DeclarationNode::uuFloat80 || td->basictype == DeclarationNode::uuFloat128) && td->complextype == DeclarationNode::Complex ) { // gcc unsupported
-                        genTSError( DeclarationNode::complexTypeNames[ td->complextype ], td->basictype );
-                } // if
                 if ( td->length == DeclarationNode::Long ) {
                         const_cast<TypeData *>(td)->basictype = DeclarationNode::LongDouble;
                 } // if
+                if ( td->basictype == DeclarationNode::Float80 || td->basictype == DeclarationNode::Float128 ) {
+                        // if ( td->complextype != DeclarationNode::NoComplexType ) {
+                        //      genTSError( DeclarationNode::complexTypeNames[ td->complextype ], td->basictype );
+                        // }
+                        if ( td->basictype == DeclarationNode::Float80 ) ret = BasicType::Float80;
+                        else ret = BasicType::Float128;
+                        break;
+                }
                 ret = floattype[ td->complextype ][ td->basictype - DeclarationNode::Float ];
-                //printf( "XXXX %d %d %d %d\n", td->complextype, td->basictype, DeclarationNode::Float, ret );
                 break;

src/Parser/TypeData.h

-              r933f32f
+              r6a9d4b4
         struct Aggregate_t {
                 DeclarationNode::Aggregate kind;
                 const std::string * name = nullptr;
                 DeclarationNode * params = nullptr;
                 ExpressionNode * actuals = nullptr;                                             // holds actual parameters later applied to AggInst
                 DeclarationNode * fields = nullptr;
+                const std::string * name;
+                DeclarationNode * params;
+                ExpressionNode * actuals;                                               // holds actual parameters later applied to AggInst
+                DeclarationNode * fields;
                 bool body;
                 bool anon;
                 bool tagged;
                 const std::string * parent = nullptr;
+                const std::string * parent;
         };
         struct AggInst_t {
                 TypeData * aggregate = nullptr;
                 ExpressionNode * params = nullptr;
+                TypeData * aggregate;
+                ExpressionNode * params;
                 bool hoistType;
         };
         struct Array_t {
                 ExpressionNode * dimension = nullptr;
+                ExpressionNode * dimension;
                 bool isVarLen;
                 bool isStatic;
 …
         struct Enumeration_t {
                 const std::string * name = nullptr;
                 DeclarationNode * constants = nullptr;
+                const std::string * name;
+                DeclarationNode * constants;
                 bool body;
                 bool anon;
 …
         struct Function_t {
                 mutable DeclarationNode * params = nullptr;                             // mutables modified in buildKRFunction
                 mutable DeclarationNode * idList = nullptr;                             // old-style
                 mutable DeclarationNode * oldDeclList = nullptr;
                 StatementNode * body = nullptr;
                 ExpressionNode * withExprs = nullptr;                                           // expressions from function's with_clause
+                mutable DeclarationNode * params;                               // mutables modified in buildKRFunction
+                mutable DeclarationNode * idList;                               // old-style
+                mutable DeclarationNode * oldDeclList;
+                StatementNode * body;
+                ExpressionNode * withExprs;                                             // expressions from function's with_clause
         };
         struct Symbolic_t {
                 const std::string * name = nullptr;
+                const std::string * name;
                 bool isTypedef;                                                                 // false => TYPEGENname, true => TYPEDEFname
                 DeclarationNode * params = nullptr;
                 ExpressionNode * actuals = nullptr;
                 DeclarationNode * assertions = nullptr;
+                DeclarationNode * params;
+                ExpressionNode * actuals;
+                DeclarationNode * assertions;
         };
         struct Qualified_t {                                                            // qualified type S.T
                 TypeData * parent = nullptr;
                 TypeData * child = nullptr;
+                TypeData * parent;
+                TypeData * child;
         };
 …
         Type::Qualifiers qualifiers;
         DeclarationNode * forall = nullptr;
+        DeclarationNode * forall;
         Aggregate_t aggregate;
 …
         Symbolic_t symbolic;
         Qualified_t qualified;
         DeclarationNode * tuple = nullptr;
         ExpressionNode * typeexpr = nullptr;
+        DeclarationNode * tuple;
+        ExpressionNode * typeexpr;
         TypeData( Kind k = Unknown );

src/Parser/lex.ll

-              r933f32f
+              r6a9d4b4
  * Created On       : Sat Sep 22 08:58:10 2001
  * Last Modified By : Peter A. Buhr
  * Last Modified On : Wed May 15 21:25:27 2019
  * Update Count     : 708
+ * Last Modified On : Thu Nov  1 20:57:35 2018
+ * Update Count     : 687
  */
 …
 using namespace std;
-#include "config.h"                                                                             // configure info
 #include "ParseNode.h"
 #include "TypedefTable.h"
 …
 #define IDENTIFIER_RETURN()     RETURN_VAL( typedefTable.isKind( yytext ) )
 #define ATTRIBUTE_RETURN()      RETURN_VAL( ATTR_IDENTIFIER )
-#ifdef HAVE_KEYWORDS_FLOATXX                                                            // GCC >= 7 => keyword, otherwise typedef
-#define FLOATXX(v) KEYWORD_RETURN(v);
-#else
-#define FLOATXX(v) IDENTIFIER_RETURN();
-#endif // HAVE_KEYWORDS_FLOATXX
 void rm_underscore() {
 …
 hex_quad {hex}("_"?{hex}){3}
 size_opt (8|16|32|64|128)?
+                                // CFA: explicit l8/l16/l32/l64/l128, char 'hh', short 'h', int 'n'
+length ("ll"|"LL"|[lL]{size_opt})|("hh"|"HH"|[hHnN])
+                                // CFA: size_t 'z', pointer 'p', which define a sign and length
+integer_suffix_opt ("_"?(([uU]({length}?[iI]?)|([iI]{length}))|([iI]({length}?[uU]?)|([uU]{length}))|({length}([iI]?[uU]?)|([uU][iI]))|[zZ]|[pP]))?
+length ("ll"|"LL"|[lL]{size_opt})|("hh"|"HH"|[hH])
+integer_suffix_opt ("_"?(([uU]({length}?[iI]?)|([iI]{length}))|([iI]({length}?[uU]?)|([uU]{length}))|({length}([iI]?[uU]?)|([uU][iI]))|[zZ]))?
 octal_digits ({octal})|({octal}({octal}|"_")*{octal})
 …
                                 // GCC: D (double) and iI (imaginary) suffixes, and DL (long double)
 exponent "_"?[eE]"_"?[+-]?{decimal_digits}
 floating_size 16|32|32x|64|64x|80|128|128x
 floating_length ([fFdDlLwWqQ]|[fF]{floating_size})
+floating_size 32|64|80|128
+floating_length ([fFdDlL]|[lL]{floating_size})
 floating_suffix ({floating_length}?[iI]?)|([iI]{floating_length})
 floating_suffix_opt ("_"?({floating_suffix}|"DL"))?
 …
 char                    { KEYWORD_RETURN(CHAR); }
 choose                  { KEYWORD_RETURN(CHOOSE); }                             // CFA
-coerce                  { KEYWORD_RETURN(COERCE); }                             // CFA
 _Complex                { KEYWORD_RETURN(COMPLEX); }                    // C99
 __complex               { KEYWORD_RETURN(COMPLEX); }                    // GCC
 …
 finally                 { KEYWORD_RETURN(FINALLY); }                    // CFA
 float                   { KEYWORD_RETURN(FLOAT); }
+__float80               { KEYWORD_RETURN(uuFLOAT80); }                  // GCC
+float80                 { KEYWORD_RETURN(uuFLOAT80); }                  // GCC
+__float128              { KEYWORD_RETURN(uuFLOAT128); }                 // GCC
+float128                { KEYWORD_RETURN(uuFLOAT128); }                 // GCC
+_Float16                { FLOATXX(uFLOAT16); }                                  // GCC
+_Float32                { FLOATXX(uFLOAT32); }                                  // GCC
+_Float32x               { FLOATXX(uFLOAT32X); }                                 // GCC
+_Float64                { FLOATXX(uFLOAT64); }                                  // GCC
+_Float64x               { FLOATXX(uFLOAT64X); }                                 // GCC
+_Float128               { FLOATXX(uFLOAT128); }                                 // GCC
+_Float128x              { FLOATXX(uFLOAT128); }                                 // GCC
+_Float32                { KEYWORD_RETURN(FLOAT); }                              // GCC
+_Float32x               { KEYWORD_RETURN(FLOAT); }                              // GCC
+_Float64                { KEYWORD_RETURN(DOUBLE); }                             // GCC
+_Float64x               { KEYWORD_RETURN(DOUBLE); }                             // GCC
+__float80               { KEYWORD_RETURN(FLOAT80); }                    // GCC
+float80                 { KEYWORD_RETURN(FLOAT80); }                    // GCC
+_Float128               { KEYWORD_RETURN(FLOAT128); }                   // GCC
+_Float128x              { KEYWORD_RETURN(FLOAT128); }                   // GCC
+__float128              { KEYWORD_RETURN(FLOAT128); }                   // GCC
+float128                { KEYWORD_RETURN(FLOAT128); }                   // GCC
 for                             { KEYWORD_RETURN(FOR); }
 forall                  { KEYWORD_RETURN(FORALL); }                             // CFA
 fortran                 { KEYWORD_RETURN(FORTRAN); }
 ftype                   { KEYWORD_RETURN(FTYPE); }                              // CFA
-generator               { KEYWORD_RETURN(GENERATOR); }                  // CFA
 _Generic                { KEYWORD_RETURN(GENERIC); }                    // C11
 goto                    { KEYWORD_RETURN(GOTO); }

src/Parser/module.mk

-              r933f32f
+              r6a9d4b4
        Parser/parserutility.cc
-SRCDEMANGLE += \
-        Parser/LinkageSpec.cc
 MOSTLYCLEANFILES += Parser/lex.cc Parser/parser.cc Parser/parser.hh Parser/parser.output

src/Parser/parser.yy

-              r933f32f
+              r6a9d4b4
 // Created On       : Sat Sep  1 20:22:55 2001
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed May 15 21:25:27 2019
 // Update Count     : 4296
+// Last Modified On : Thu Nov  8 18:08:23 2018
+// Update Count     : 4052
 //
 …
         // distribute declaration_specifier across all declared variables, e.g., static, const, __attribute__.
         DeclarationNode * cur = declList, * cl = (new DeclarationNode)->addType( specifier );
+        for ( cur = dynamic_cast<DeclarationNode *>( cur->get_next() ); cur != nullptr; cur = dynamic_cast<DeclarationNode *>( cur->get_next() ) ) {
+        //cur->addType( specifier );
+        for ( cur = dynamic_cast< DeclarationNode * >( cur->get_next() ); cur != nullptr; cur = dynamic_cast< DeclarationNode * >( cur->get_next() ) ) {
                 cl->cloneBaseType( cur );
         } // for
         declList->addType( cl );
+//      delete cl;
         return declList;
 } // distAttr
 …
 DeclarationNode * fieldDecl( DeclarationNode * typeSpec, DeclarationNode * fieldList ) {
         if ( ! fieldList ) {                                                            // field declarator ?
                 if ( ! ( typeSpec->type && (typeSpec->type->kind == TypeData::Aggregate || typeSpec->type->kind == TypeData::Enum) ) ) {
+                if ( ! ( typeSpec->type && typeSpec->type->kind == TypeData::Aggregate ) ) {
                         stringstream ss;
                         typeSpec->type->print( ss );
 …
 ForCtrl * forCtrl( ExpressionNode * type, string * index, ExpressionNode * start, enum OperKinds compop, ExpressionNode * comp, ExpressionNode * inc ) {
         ConstantExpr * constant = dynamic_cast<ConstantExpr *>(type->expr.get());
+        ConstantExpr * constant = dynamic_cast<ConstantExpr *>(type->get_expr());
         if ( constant && (constant->get_constant()->get_value() == "0" || constant->get_constant()->get_value() == "1") ) {
         type = new ExpressionNode( new CastExpr( maybeMoveBuild< Expression >(type), new BasicType( Type::Qualifiers(), BasicType::SignedInt ) ) );
 …
         return new ForCtrl(
                 distAttr( DeclarationNode::newTypeof( type, true ), DeclarationNode::newName( index )->addInitializer( new InitializerNode( start ) ) ),
+                // NULL comp/inc => leave blank
+                comp ? new ExpressionNode( build_binary_val( compop, new ExpressionNode( build_varref( new string( *index ) ) ), comp ) ) : 0,
+                inc ? new ExpressionNode( build_binary_val( compop == OperKinds::LThan || compop == OperKinds::LEThan ? // choose += or -= for upto/downto
+                                                        OperKinds::PlusAssn : OperKinds::MinusAssn, new ExpressionNode( build_varref( new string( *index ) ) ), inc ) ) : 0 );
+                new ExpressionNode( build_binary_val( compop, new ExpressionNode( build_varref( new string( *index ) ) ), comp ) ),
+                new ExpressionNode( build_binary_val( compop == OperKinds::LThan || compop == OperKinds::LEThan ? // choose += or -= for upto/downto
+                                                                                          OperKinds::PlusAssn : OperKinds::MinusAssn, new ExpressionNode( build_varref( new string( *index ) ) ), inc ) ) );
 } // forCtrl
 ForCtrl * forCtrl( ExpressionNode * type, ExpressionNode * index, ExpressionNode * start, enum OperKinds compop, ExpressionNode * comp, ExpressionNode * inc ) {
         if ( NameExpr * identifier = dynamic_cast<NameExpr *>(index->expr.get()) ) {
+        if ( NameExpr * identifier = dynamic_cast<NameExpr *>(index->get_expr()) ) {
                 return forCtrl( type, new string( identifier->name ), start, compop, comp, inc );
-        } else if ( CommaExpr * commaExpr = dynamic_cast<CommaExpr *>(index->expr.get()) ) {
-                if ( NameExpr * identifier = dynamic_cast<NameExpr *>(commaExpr->arg1 ) ) {
-                        return forCtrl( type, new string( identifier->name ), start, compop, comp, inc );
-                } else {
-                        SemanticError( yylloc, "Expression disallowed. Only loop-index name allowed" ); return nullptr;
-                } // if
         } else {
                 SemanticError( yylloc, "Expression disallowed. Only loop-index name allowed" ); return nullptr;
 …
 %token RESTRICT                                                                                 // C99
 %token ATOMIC                                                                                   // C11
 %token FORALL MUTEX VIRTUAL COERCE                                              // CFA
+%token FORALL MUTEX VIRTUAL                                                             // CFA
 %token VOID CHAR SHORT INT LONG FLOAT DOUBLE SIGNED UNSIGNED
 %token BOOL COMPLEX IMAGINARY                                                   // C99
+%token INT128 uuFLOAT80 uuFLOAT128                                              // GCC
+%token uFLOAT16 uFLOAT32 uFLOAT32X uFLOAT64 uFLOAT64X uFLOAT128 // GCC
+%token INT128 FLOAT80 FLOAT128                                                  // GCC
 %token ZERO_T ONE_T                                                                             // CFA
 %token VALIST                                                                                   // GCC
 …
 %token ENUM STRUCT UNION
 %token EXCEPTION                                                                                // CFA
 %token GENERATOR COROUTINE MONITOR THREAD                               // CFA
+%token COROUTINE MONITOR THREAD                                                 // CFA
 %token OTYPE FTYPE DTYPE TTYPE TRAIT                                    // CFA
 %token SIZEOF OFFSETOF
 …
 %type<en> argument_expression_list              argument_expression                     default_initialize_opt
 %type<ifctl> if_control_expression
 %type<fctl> for_control_expression              for_control_expression_list
+%type<fctl> for_control_expression
 %type<compop> inclexcl
 %type<en> subrange
 %type<decl> asm_name_opt
 %type<en> asm_operands_opt                              asm_operands_list                       asm_operand
+%type<en> asm_operands_opt asm_operands_list asm_operand
 %type<label> label_list
 %type<en> asm_clobbers_list_opt
 %type<flag> asm_volatile_opt
 %type<en> handler_predicate_opt
 %type<genexpr> generic_association              generic_assoc_list
+%type<genexpr> generic_association generic_assoc_list
 // statements
 …
         // empty
                 { $$ = nullptr; }
         | '@'                                                                                           // CFA, default parameter
+        | '?'                                                                                           // CFA, default parameter
                 { SemanticError( yylloc, "Default parameter for argument is currently unimplemented." ); $$ = nullptr; }
                 // { $$ = new ExpressionNode( build_constantInteger( *new string( "2" ) ) ); }
 …
         | '(' type_no_function ')' cast_expression
                 { $$ = new ExpressionNode( build_cast( $2, $4 ) ); }
-                // 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 ) ); }
 …
         | '(' VIRTUAL type_no_function ')' cast_expression      // CFA
                 { $$ = new ExpressionNode( new VirtualCastExpr( maybeMoveBuild< Expression >( $5 ), maybeMoveBuildType( $3 ) ) ); }
-        | '(' RETURN type_no_function ')' cast_expression       // CFA
-                { SemanticError( yylloc, "Return cast is currently unimplemented." ); $$ = nullptr; }
-        | '(' COERCE type_no_function ')' cast_expression       // CFA
-                { SemanticError( yylloc, "Coerce cast is currently unimplemented." ); $$ = nullptr; }
-        | '(' qualifier_cast_list ')' cast_expression           // CFA
-                { SemanticError( yylloc, "Qualifier cast is currently unimplemented." ); $$ = nullptr; }
 //      | '(' type_no_function ')' tuple
 //              { $$ = new ExpressionNode( build_cast( $2, $4 ) ); }
+        ;
-qualifier_cast_list:
-        cast_modifier type_qualifier_name
-        | cast_modifier MUTEX
-        | qualifier_cast_list cast_modifier type_qualifier_name
-        | qualifier_cast_list cast_modifier MUTEX
+        ;
-cast_modifier:
-        '-'
-        | '+'
+        ;
 …
                 // labels cannot be identifiers 0 or 1 or ATTR_IDENTIFIER
         identifier_or_type_name ':' attribute_list_opt statement
+                { $$ = $4->add_label( $1, $3 ); }
+                {
+                        $$ = $4->add_label( $1, $3 );
+                }
+        ;
 …
         statement_decl
         | statement_decl_list statement_decl
                 { assert( $1 ); $1->set_last( $2 ); $$ = $1; }
+                { if ( $1 != 0 ) { $1->set_last( $2 ); $$ = $1; } }
+        ;
 …
                 { $$ = new StatementNode( $1 ); }
         | EXTENSION declaration                                                         // GCC
+                { distExt( $2 ); $$ = new StatementNode( $2 ); }
+                {
+                        distExt( $2 );
+                        $$ = new StatementNode( $2 );
+                }
         | function_definition
                 { $$ = new StatementNode( $1 ); }
         | EXTENSION function_definition                                         // GCC
+                { distExt( $2 ); $$ = new StatementNode( $2 ); }
+                {
+                        distExt( $2 );
+                        $$ = new StatementNode( $2 );
+                }
         | statement
+        ;
 …
         statement
         | statement_list_nodecl statement
                 { assert( $1 ); $1->set_last( $2 ); $$ = $1; }
+                { if ( $1 != 0 ) { $1->set_last( $2 ); $$ = $1; } }
+        ;
 …
         | DO statement WHILE '(' ')' ';'                                        // CFA => do while( 1 )
                 { $$ = new StatementNode( build_do_while( new ExpressionNode( build_constantInteger( *new string( "1" ) ) ), $2 ) ); }
         | FOR '(' push for_control_expression_list ')' statement pop
+        | FOR '(' push for_control_expression ')' statement pop
                 { $$ = new StatementNode( build_for( $4, $6 ) ); }
         | FOR '(' ')' statement                                                         // CFA => for ( ;; )
 …
+        ;
-for_control_expression_list:
-        for_control_expression
-        | for_control_expression_list ':' for_control_expression
-                // ForCtrl + ForCtrl:
-                //    init + init => multiple declaration statements that are hoisted
-                //    condition + condition => (expression) && (expression)
-                //    change + change => (expression), (expression)
+                {
-                        $1->init->set_last( $3->init );
-                        if ( $1->condition ) {
-                                if ( $3->condition ) {
-                                        $1->condition->expr.reset( new LogicalExpr( $1->condition->expr.release(), $3->condition->expr.release(), true ) );
-                                } // if
-                        } else $1->condition = $3->condition;
-                        if ( $1->change ) {
-                                if ( $3->change ) {
-                                        $1->change->expr.reset( new CommaExpr( $1->change->expr.release(), $3->change->expr.release() ) );
-                                } // if
-                        } else $1->change = $3->change;
-                        $$ = $1;
+                }
+        ;
 for_control_expression:
+        ';' comma_expression_opt ';' comma_expression_opt
+                { $$ = new ForCtrl( (ExpressionNode * )nullptr, $2, $4 ); }
+        | comma_expression ';' comma_expression_opt ';' comma_expression_opt
+                { $$ = new ForCtrl( $1, $3, $5 ); }
+        | declaration comma_expression_opt ';' comma_expression_opt // C99, declaration has ';'
+                { $$ = new ForCtrl( $1, $2, $4 ); }
+        | comma_expression                                                                      // CFA
+        comma_expression                                                                        // CFA
                 { $$ = 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 inclexcl comma_expression            // CFA
+        | constant_expression inclexcl constant_expression      // CFA
                 { $$ = forCtrl( $1, new string( DeclarationNode::anonymous.newName() ), $1->clone(), $2, $3, new ExpressionNode( build_constantInteger( *new string( "1" ) ) ) ); }
         | comma_expression inclexcl comma_expression '~' comma_expression // CFA
+        | constant_expression inclexcl constant_expression '~' constant_expression // CFA
                 { $$ = forCtrl( $1, new string( DeclarationNode::anonymous.newName() ), $1->clone(), $2, $3, $5 ); }
         | comma_expression ';' comma_expression                         // CFA
                 { $$ = 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 inclexcl comma_expression // CFA
+        | comma_expression ';' constant_expression inclexcl constant_expression // CFA
                 { $$ = forCtrl( $3, $1, $3->clone(), $4, $5, new ExpressionNode( build_constantInteger( *new string( "1" ) ) ) ); }
         | comma_expression ';' comma_expression inclexcl comma_expression '~' comma_expression // CFA
+        | comma_expression ';' constant_expression inclexcl constant_expression '~' constant_expression // CFA
                 { $$ = forCtrl( $3, $1, $3->clone(), $4, $5, $7 ); }
+                // There is a S/R conflicit if ~ and -~ are factored out.
+        | comma_expression ';' comma_expression '~' '@'         // CFA
+                { $$ = forCtrl( $3, $1, $3->clone(), OperKinds::LThan, nullptr, new ExpressionNode( build_constantInteger( *new string( "1" ) ) ) ); }
+        | comma_expression ';' comma_expression ErangeDown '@' // CFA
+                { $$ = forCtrl( $3, $1, $3->clone(), OperKinds::GThan, nullptr, new ExpressionNode( build_constantInteger( *new string( "1" ) ) ) ); }
+        | comma_expression ';' comma_expression '~' '@' '~' comma_expression // CFA
+                { $$ = forCtrl( $3, $1, $3->clone(), OperKinds::LThan, nullptr, $7 ); }
+        | comma_expression ';' comma_expression ErangeDown '@' '~' comma_expression // CFA
+                { $$ = forCtrl( $3, $1, $3->clone(), OperKinds::GThan, nullptr, $7 ); }
+        | comma_expression ';' comma_expression '~' '@' '~' '@' // CFA
+                { $$ = forCtrl( $3, $1, $3->clone(), OperKinds::LThan, nullptr, nullptr ); }
+        | comma_expression ';' comma_expression_opt ';' comma_expression_opt
+                { $$ = new ForCtrl( $1, $3, $5 ); }
+        | ';' comma_expression_opt ';' comma_expression_opt
+                { $$ = new ForCtrl( (ExpressionNode * )nullptr, $2, $4 ); }
+        | declaration comma_expression_opt ';' comma_expression_opt // C99, declaration has ';'
+                { $$ = new ForCtrl( $1, $2, $4 ); }
+        ;
 …
         | FLOAT
                 { $$ = DeclarationNode::newBasicType( DeclarationNode::Float ); }
+        | FLOAT80
+                { $$ = DeclarationNode::newBasicType( DeclarationNode::Float80 ); }
+        | FLOAT128
+                { $$ = DeclarationNode::newBasicType( DeclarationNode::Float128 ); }
         | DOUBLE
                 { $$ = DeclarationNode::newBasicType( DeclarationNode::Double ); }
-        | uuFLOAT80
-                { $$ = DeclarationNode::newBasicType( DeclarationNode::uuFloat80 ); }
-        | uuFLOAT128
-                { $$ = DeclarationNode::newBasicType( DeclarationNode::uuFloat128 ); }
-        | uFLOAT16
-                { $$ = DeclarationNode::newBasicType( DeclarationNode::uFloat16 ); }
-        | uFLOAT32
-                { $$ = DeclarationNode::newBasicType( DeclarationNode::uFloat32 ); }
-        | uFLOAT32X
-                { $$ = DeclarationNode::newBasicType( DeclarationNode::uFloat32x ); }
-        | uFLOAT64
-                { $$ = DeclarationNode::newBasicType( DeclarationNode::uFloat64 ); }
-        | uFLOAT64X
-                { $$ = DeclarationNode::newBasicType( DeclarationNode::uFloat64x ); }
-        | uFLOAT128
-                { $$ = DeclarationNode::newBasicType( DeclarationNode::uFloat128 ); }
         | COMPLEX                                                                                       // C99
                 { $$ = DeclarationNode::newComplexType( DeclarationNode::Complex ); }
 …
         | EXCEPTION
                 { yyy = true; $$ = DeclarationNode::Exception; }
-        | GENERATOR
-                { yyy = true; $$ = DeclarationNode::Coroutine; }
         | COROUTINE
                 { yyy = true; $$ = DeclarationNode::Coroutine; }

src/ResolvExpr/AlternativeFinder.cc

-              r933f32f
+              r6a9d4b4
                         // - necessary pre-requisite to pruning
                         AltList candidates;
-                        std::list<std::string> errors;
                         for ( unsigned i = 0; i < alternatives.size(); ++i ) {
                                 resolveAssertions( alternatives[i], indexer, candidates, errors );
+                                resolveAssertions( alternatives[i], indexer, candidates );
+                        }
                         // fail early if none such
                         if ( mode.failFast && candidates.empty() ) {
                                 std::ostringstream stream;
+                                stream << "No alternatives with satisfiable assertions for " << expr << "\n";
+                                //        << "Alternatives with failing assertions are:\n";
+                                // printAlts( alternatives, stream, 1 );
+                                for ( const auto& err : errors ) {
+                                        stream << err;
+                                }
+                                stream << "No resolvable alternatives for expression " << expr << "\n"
+                                       << "Alternatives with failing assertions are:\n";
+                                printAlts( alternatives, stream, 1 );
                                 SemanticError( expr->location, stream.str() );
+                        }

src/ResolvExpr/CommonType.cc

-              r933f32f
+              r6a9d4b4
 // Created On       : Sun May 17 06:59:27 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Feb 14 17:10:10 2019
 // Update Count     : 24
+// Last Modified On : Mon Sep 25 15:18:17 2017
+// Update Count     : 9
 //
 …
+        }
+        // GENERATED START, DO NOT EDIT
+        // GENERATED BY BasicTypes-gen.cc
+        #define BT BasicType::
+        static const BasicType::Kind commonTypes[BasicType::NUMBER_OF_BASIC_TYPES][BasicType::NUMBER_OF_BASIC_TYPES] = { // nearest common ancestor
+                /*                                      B                       C                      SC                      UC                      SI                     SUI
+                                                        I                      UI                      LI                     LUI                     LLI                    LLUI
+                                                       IB                     UIB                     _FH                     _FH                      _F                     _FC
+                                                        F                      FC                     _FX                    _FXC                      FD                    _FDC
+                                                        D                      DC                    F80X                   _FDXC                     F80                     _FB
+                                                    _FLDC                      FB                      LD                     LDC                    _FBX                  _FLDXC
+                                 */
+                                  {
+                /*     B*/                BT Bool,                BT Char,          BT SignedChar,        BT UnsignedChar,      BT ShortSignedInt,    BT ShortUnsignedInt,
+                                             BT SignedInt,         BT UnsignedInt,       BT LongSignedInt,     BT LongUnsignedInt,   BT LongLongSignedInt, BT LongLongUnsignedInt,
+                                          BT SignedInt128,      BT UnsignedInt128,            BT uFloat16,     BT uFloat16Complex,            BT uFloat32,     BT uFloat32Complex,
+                                                 BT Float,        BT FloatComplex,           BT uFloat32x,    BT uFloat32xComplex,            BT uFloat64,     BT uFloat64Complex,
+                                                BT Double,       BT DoubleComplex,           BT uFloat64x,    BT uFloat64xComplex,           BT uuFloat80,           BT uFloat128,
+                                      BT uFloat128Complex,          BT uuFloat128,          BT LongDouble,   BT LongDoubleComplex,          BT uFloat128x,   BT uFloat128xComplex,
+                                  },
+                                  {
+                /*     C*/                BT Char,                BT Char,          BT SignedChar,        BT UnsignedChar,      BT ShortSignedInt,    BT ShortUnsignedInt,
+                                             BT SignedInt,         BT UnsignedInt,       BT LongSignedInt,     BT LongUnsignedInt,   BT LongLongSignedInt, BT LongLongUnsignedInt,
+                                          BT SignedInt128,      BT UnsignedInt128,            BT uFloat16,     BT uFloat16Complex,            BT uFloat32,     BT uFloat32Complex,
+                                                 BT Float,        BT FloatComplex,           BT uFloat32x,    BT uFloat32xComplex,            BT uFloat64,     BT uFloat64Complex,
+                                                BT Double,       BT DoubleComplex,           BT uFloat64x,    BT uFloat64xComplex,           BT uuFloat80,           BT uFloat128,
+                                      BT uFloat128Complex,          BT uuFloat128,          BT LongDouble,   BT LongDoubleComplex,          BT uFloat128x,   BT uFloat128xComplex,
+                                  },
+                                  {
+                /*    SC*/          BT SignedChar,          BT SignedChar,          BT SignedChar,        BT UnsignedChar,      BT ShortSignedInt,    BT ShortUnsignedInt,
+                                             BT SignedInt,         BT UnsignedInt,       BT LongSignedInt,     BT LongUnsignedInt,   BT LongLongSignedInt, BT LongLongUnsignedInt,
+                                          BT SignedInt128,      BT UnsignedInt128,            BT uFloat16,     BT uFloat16Complex,            BT uFloat32,     BT uFloat32Complex,
+                                                 BT Float,        BT FloatComplex,           BT uFloat32x,    BT uFloat32xComplex,            BT uFloat64,     BT uFloat64Complex,
+                                                BT Double,       BT DoubleComplex,           BT uFloat64x,    BT uFloat64xComplex,           BT uuFloat80,           BT uFloat128,
+                                      BT uFloat128Complex,          BT uuFloat128,          BT LongDouble,   BT LongDoubleComplex,          BT uFloat128x,   BT uFloat128xComplex,
+                                  },
+                                  {
+                /*    UC*/        BT UnsignedChar,        BT UnsignedChar,        BT UnsignedChar,        BT UnsignedChar,      BT ShortSignedInt,    BT ShortUnsignedInt,
+                                             BT SignedInt,         BT UnsignedInt,       BT LongSignedInt,     BT LongUnsignedInt,   BT LongLongSignedInt, BT LongLongUnsignedInt,
+                                          BT SignedInt128,      BT UnsignedInt128,            BT uFloat16,     BT uFloat16Complex,            BT uFloat32,     BT uFloat32Complex,
+                                                 BT Float,        BT FloatComplex,           BT uFloat32x,    BT uFloat32xComplex,            BT uFloat64,     BT uFloat64Complex,
+                                                BT Double,       BT DoubleComplex,           BT uFloat64x,    BT uFloat64xComplex,           BT uuFloat80,           BT uFloat128,
+                                      BT uFloat128Complex,          BT uuFloat128,          BT LongDouble,   BT LongDoubleComplex,          BT uFloat128x,   BT uFloat128xComplex,
+                                  },
+                                  {
+                /*    SI*/      BT ShortSignedInt,      BT ShortSignedInt,      BT ShortSignedInt,      BT ShortSignedInt,      BT ShortSignedInt,    BT ShortUnsignedInt,
+                                             BT SignedInt,         BT UnsignedInt,       BT LongSignedInt,     BT LongUnsignedInt,   BT LongLongSignedInt, BT LongLongUnsignedInt,
+                                          BT SignedInt128,      BT UnsignedInt128,            BT uFloat16,     BT uFloat16Complex,            BT uFloat32,     BT uFloat32Complex,
+                                                 BT Float,        BT FloatComplex,           BT uFloat32x,    BT uFloat32xComplex,            BT uFloat64,     BT uFloat64Complex,
+                                                BT Double,       BT DoubleComplex,           BT uFloat64x,    BT uFloat64xComplex,           BT uuFloat80,           BT uFloat128,
+                                      BT uFloat128Complex,          BT uuFloat128,          BT LongDouble,   BT LongDoubleComplex,          BT uFloat128x,   BT uFloat128xComplex,
+                                  },
+                                  {
+                /*   SUI*/    BT ShortUnsignedInt,    BT ShortUnsignedInt,    BT ShortUnsignedInt,    BT ShortUnsignedInt,    BT ShortUnsignedInt,    BT ShortUnsignedInt,
+                                             BT SignedInt,         BT UnsignedInt,       BT LongSignedInt,     BT LongUnsignedInt,   BT LongLongSignedInt, BT LongLongUnsignedInt,
+                                          BT SignedInt128,      BT UnsignedInt128,            BT uFloat16,     BT uFloat16Complex,            BT uFloat32,     BT uFloat32Complex,
+                                                 BT Float,        BT FloatComplex,           BT uFloat32x,    BT uFloat32xComplex,            BT uFloat64,     BT uFloat64Complex,
+                                                BT Double,       BT DoubleComplex,           BT uFloat64x,    BT uFloat64xComplex,           BT uuFloat80,           BT uFloat128,
+                                      BT uFloat128Complex,          BT uuFloat128,          BT LongDouble,   BT LongDoubleComplex,          BT uFloat128x,   BT uFloat128xComplex,
+                                  },
+                                  {
+                /*     I*/           BT SignedInt,           BT SignedInt,           BT SignedInt,           BT SignedInt,           BT SignedInt,           BT SignedInt,
+                                             BT SignedInt,         BT UnsignedInt,       BT LongSignedInt,     BT LongUnsignedInt,   BT LongLongSignedInt, BT LongLongUnsignedInt,
+                                          BT SignedInt128,      BT UnsignedInt128,            BT uFloat16,     BT uFloat16Complex,            BT uFloat32,     BT uFloat32Complex,
+                                                 BT Float,        BT FloatComplex,           BT uFloat32x,    BT uFloat32xComplex,            BT uFloat64,     BT uFloat64Complex,
+                                                BT Double,       BT DoubleComplex,           BT uFloat64x,    BT uFloat64xComplex,           BT uuFloat80,           BT uFloat128,
+                                      BT uFloat128Complex,          BT uuFloat128,          BT LongDouble,   BT LongDoubleComplex,          BT uFloat128x,   BT uFloat128xComplex,
+                                  },
+                                  {
+                /*    UI*/         BT UnsignedInt,         BT UnsignedInt,         BT UnsignedInt,         BT UnsignedInt,         BT UnsignedInt,         BT UnsignedInt,
+                                           BT UnsignedInt,         BT UnsignedInt,       BT LongSignedInt,     BT LongUnsignedInt,   BT LongLongSignedInt, BT LongLongUnsignedInt,
+                                          BT SignedInt128,      BT UnsignedInt128,            BT uFloat16,     BT uFloat16Complex,            BT uFloat32,     BT uFloat32Complex,
+                                                 BT Float,        BT FloatComplex,           BT uFloat32x,    BT uFloat32xComplex,            BT uFloat64,     BT uFloat64Complex,
+                                                BT Double,       BT DoubleComplex,           BT uFloat64x,    BT uFloat64xComplex,           BT uuFloat80,           BT uFloat128,
+                                      BT uFloat128Complex,          BT uuFloat128,          BT LongDouble,   BT LongDoubleComplex,          BT uFloat128x,   BT uFloat128xComplex,
+                                  },
+                                  {
+                /*    LI*/       BT LongSignedInt,       BT LongSignedInt,       BT LongSignedInt,       BT LongSignedInt,       BT LongSignedInt,       BT LongSignedInt,
+                                         BT LongSignedInt,       BT LongSignedInt,       BT LongSignedInt,     BT LongUnsignedInt,   BT LongLongSignedInt, BT LongLongUnsignedInt,
+                                          BT SignedInt128,      BT UnsignedInt128,            BT uFloat16,     BT uFloat16Complex,            BT uFloat32,     BT uFloat32Complex,
+                                                 BT Float,        BT FloatComplex,           BT uFloat32x,    BT uFloat32xComplex,            BT uFloat64,     BT uFloat64Complex,
+                                                BT Double,       BT DoubleComplex,           BT uFloat64x,    BT uFloat64xComplex,           BT uuFloat80,           BT uFloat128,
+                                      BT uFloat128Complex,          BT uuFloat128,          BT LongDouble,   BT LongDoubleComplex,          BT uFloat128x,   BT uFloat128xComplex,
+                                  },
+                                  {
+                /*   LUI*/     BT LongUnsignedInt,     BT LongUnsignedInt,     BT LongUnsignedInt,     BT LongUnsignedInt,     BT LongUnsignedInt,     BT LongUnsignedInt,
+                                       BT LongUnsignedInt,     BT LongUnsignedInt,     BT LongUnsignedInt,     BT LongUnsignedInt,   BT LongLongSignedInt, BT LongLongUnsignedInt,
+                                          BT SignedInt128,      BT UnsignedInt128,            BT uFloat16,     BT uFloat16Complex,            BT uFloat32,     BT uFloat32Complex,
+                                                 BT Float,        BT FloatComplex,           BT uFloat32x,    BT uFloat32xComplex,            BT uFloat64,     BT uFloat64Complex,
+                                                BT Double,       BT DoubleComplex,           BT uFloat64x,    BT uFloat64xComplex,           BT uuFloat80,           BT uFloat128,
+                                      BT uFloat128Complex,          BT uuFloat128,          BT LongDouble,   BT LongDoubleComplex,          BT uFloat128x,   BT uFloat128xComplex,
+                                  },
+                                  {
+                /*   LLI*/   BT LongLongSignedInt,   BT LongLongSignedInt,   BT LongLongSignedInt,   BT LongLongSignedInt,   BT LongLongSignedInt,   BT LongLongSignedInt,
+                                     BT LongLongSignedInt,   BT LongLongSignedInt,   BT LongLongSignedInt,   BT LongLongSignedInt,   BT LongLongSignedInt, BT LongLongUnsignedInt,
+                                          BT SignedInt128,      BT UnsignedInt128,            BT uFloat16,     BT uFloat16Complex,            BT uFloat32,     BT uFloat32Complex,
+                                                 BT Float,        BT FloatComplex,           BT uFloat32x,    BT uFloat32xComplex,            BT uFloat64,     BT uFloat64Complex,
+                                                BT Double,       BT DoubleComplex,           BT uFloat64x,    BT uFloat64xComplex,           BT uuFloat80,           BT uFloat128,
+                                      BT uFloat128Complex,          BT uuFloat128,          BT LongDouble,   BT LongDoubleComplex,          BT uFloat128x,   BT uFloat128xComplex,
+                                  },
+                                  {
+                /*  LLUI*/ BT LongLongUnsignedInt, BT LongLongUnsignedInt, BT LongLongUnsignedInt, BT LongLongUnsignedInt, BT LongLongUnsignedInt, BT LongLongUnsignedInt,
+                                   BT LongLongUnsignedInt, BT LongLongUnsignedInt, BT LongLongUnsignedInt, BT LongLongUnsignedInt, BT LongLongUnsignedInt, BT LongLongUnsignedInt,
+                                          BT SignedInt128,      BT UnsignedInt128,            BT uFloat16,     BT uFloat16Complex,            BT uFloat32,     BT uFloat32Complex,
+                                                 BT Float,        BT FloatComplex,           BT uFloat32x,    BT uFloat32xComplex,            BT uFloat64,     BT uFloat64Complex,
+                                                BT Double,       BT DoubleComplex,           BT uFloat64x,    BT uFloat64xComplex,           BT uuFloat80,           BT uFloat128,
+                                      BT uFloat128Complex,          BT uuFloat128,          BT LongDouble,   BT LongDoubleComplex,          BT uFloat128x,   BT uFloat128xComplex,
+                                  },
+                                  {
+                /*    IB*/        BT SignedInt128,        BT SignedInt128,        BT SignedInt128,        BT SignedInt128,        BT SignedInt128,        BT SignedInt128,
+                                          BT SignedInt128,        BT SignedInt128,        BT SignedInt128,        BT SignedInt128,        BT SignedInt128,        BT SignedInt128,
+                                          BT SignedInt128,      BT UnsignedInt128,            BT uFloat16,     BT uFloat16Complex,            BT uFloat32,     BT uFloat32Complex,
+                                                 BT Float,        BT FloatComplex,           BT uFloat32x,    BT uFloat32xComplex,            BT uFloat64,     BT uFloat64Complex,
+                                                BT Double,       BT DoubleComplex,           BT uFloat64x,    BT uFloat64xComplex,           BT uuFloat80,           BT uFloat128,
+                                      BT uFloat128Complex,          BT uuFloat128,          BT LongDouble,   BT LongDoubleComplex,          BT uFloat128x,   BT uFloat128xComplex,
+                                  },
+                                  {
+                /*   UIB*/      BT UnsignedInt128,      BT UnsignedInt128,      BT UnsignedInt128,      BT UnsignedInt128,      BT UnsignedInt128,      BT UnsignedInt128,
+                                        BT UnsignedInt128,      BT UnsignedInt128,      BT UnsignedInt128,      BT UnsignedInt128,      BT UnsignedInt128,      BT UnsignedInt128,
+                                        BT UnsignedInt128,      BT UnsignedInt128,            BT uFloat16,     BT uFloat16Complex,            BT uFloat32,     BT uFloat32Complex,
+                                                 BT Float,        BT FloatComplex,           BT uFloat32x,    BT uFloat32xComplex,            BT uFloat64,     BT uFloat64Complex,
+                                                BT Double,       BT DoubleComplex,           BT uFloat64x,    BT uFloat64xComplex,           BT uuFloat80,           BT uFloat128,
+                                      BT uFloat128Complex,          BT uuFloat128,          BT LongDouble,   BT LongDoubleComplex,          BT uFloat128x,   BT uFloat128xComplex,
+                                  },
+                                  {
+                /*   _FH*/            BT uFloat16,            BT uFloat16,            BT uFloat16,            BT uFloat16,            BT uFloat16,            BT uFloat16,
+                                              BT uFloat16,            BT uFloat16,            BT uFloat16,            BT uFloat16,            BT uFloat16,            BT uFloat16,
+                                              BT uFloat16,            BT uFloat16,            BT uFloat16,     BT uFloat16Complex,            BT uFloat32,     BT uFloat32Complex,
+                                                 BT Float,        BT FloatComplex,           BT uFloat32x,    BT uFloat32xComplex,            BT uFloat64,     BT uFloat64Complex,
+                                                BT Double,       BT DoubleComplex,           BT uFloat64x,    BT uFloat64xComplex,           BT uuFloat80,           BT uFloat128,
+                                      BT uFloat128Complex,          BT uuFloat128,          BT LongDouble,   BT LongDoubleComplex,          BT uFloat128x,   BT uFloat128xComplex,
+                                  },
+                                  {
+                /*   _FH*/     BT uFloat16Complex,     BT uFloat16Complex,     BT uFloat16Complex,     BT uFloat16Complex,     BT uFloat16Complex,     BT uFloat16Complex,
+                                       BT uFloat16Complex,     BT uFloat16Complex,     BT uFloat16Complex,     BT uFloat16Complex,     BT uFloat16Complex,     BT uFloat16Complex,
+                                       BT uFloat16Complex,     BT uFloat16Complex,     BT uFloat16Complex,     BT uFloat16Complex,     BT uFloat32Complex,     BT uFloat32Complex,
+                                          BT FloatComplex,        BT FloatComplex,    BT uFloat32xComplex,    BT uFloat32xComplex,     BT uFloat64Complex,     BT uFloat64Complex,
+                                         BT DoubleComplex,       BT DoubleComplex,    BT uFloat64xComplex,    BT uFloat64xComplex,    BT uFloat64xComplex,    BT uFloat128Complex,
+                                      BT uFloat128Complex,    BT uFloat128Complex,   BT LongDoubleComplex,   BT LongDoubleComplex,   BT uFloat128xComplex,   BT uFloat128xComplex,
+                                  },
+                                  {
+                /*    _F*/            BT uFloat32,            BT uFloat32,            BT uFloat32,            BT uFloat32,            BT uFloat32,            BT uFloat32,
+                                              BT uFloat32,            BT uFloat32,            BT uFloat32,            BT uFloat32,            BT uFloat32,            BT uFloat32,
+                                              BT uFloat32,            BT uFloat32,            BT uFloat32,     BT uFloat32Complex,            BT uFloat32,     BT uFloat32Complex,
+                                                 BT Float,        BT FloatComplex,           BT uFloat32x,    BT uFloat32xComplex,            BT uFloat64,     BT uFloat64Complex,
+                                                BT Double,       BT DoubleComplex,           BT uFloat64x,    BT uFloat64xComplex,           BT uuFloat80,           BT uFloat128,
+                                      BT uFloat128Complex,          BT uuFloat128,          BT LongDouble,   BT LongDoubleComplex,          BT uFloat128x,   BT uFloat128xComplex,
+                                  },
+                                  {
+                /*   _FC*/     BT uFloat32Complex,     BT uFloat32Complex,     BT uFloat32Complex,     BT uFloat32Complex,     BT uFloat32Complex,     BT uFloat32Complex,
+                                       BT uFloat32Complex,     BT uFloat32Complex,     BT uFloat32Complex,     BT uFloat32Complex,     BT uFloat32Complex,     BT uFloat32Complex,
+                                       BT uFloat32Complex,     BT uFloat32Complex,     BT uFloat32Complex,     BT uFloat32Complex,     BT uFloat32Complex,     BT uFloat32Complex,
+                                          BT FloatComplex,        BT FloatComplex,    BT uFloat32xComplex,    BT uFloat32xComplex,     BT uFloat64Complex,     BT uFloat64Complex,
+                                         BT DoubleComplex,       BT DoubleComplex,    BT uFloat64xComplex,    BT uFloat64xComplex,    BT uFloat64xComplex,    BT uFloat128Complex,
+                                      BT uFloat128Complex,    BT uFloat128Complex,   BT LongDoubleComplex,   BT LongDoubleComplex,   BT uFloat128xComplex,   BT uFloat128xComplex,
+                                  },
+                                  {
+                /*     F*/               BT Float,               BT Float,               BT Float,               BT Float,               BT Float,               BT Float,
+                                                 BT Float,               BT Float,               BT Float,               BT Float,               BT Float,               BT Float,
+                                                 BT Float,               BT Float,               BT Float,        BT FloatComplex,               BT Float,        BT FloatComplex,
+                                                 BT Float,        BT FloatComplex,           BT uFloat32x,    BT uFloat32xComplex,            BT uFloat64,     BT uFloat64Complex,
+                                                BT Double,       BT DoubleComplex,           BT uFloat64x,    BT uFloat64xComplex,           BT uuFloat80,           BT uFloat128,
+                                      BT uFloat128Complex,          BT uuFloat128,          BT LongDouble,   BT LongDoubleComplex,          BT uFloat128x,   BT uFloat128xComplex,
+                                  },
+                                  {
+                /*    FC*/        BT FloatComplex,        BT FloatComplex,        BT FloatComplex,        BT FloatComplex,        BT FloatComplex,        BT FloatComplex,
+                                          BT FloatComplex,        BT FloatComplex,        BT FloatComplex,        BT FloatComplex,        BT FloatComplex,        BT FloatComplex,
+                                          BT FloatComplex,        BT FloatComplex,        BT FloatComplex,        BT FloatComplex,        BT FloatComplex,        BT FloatComplex,
+                                          BT FloatComplex,        BT FloatComplex,    BT uFloat32xComplex,    BT uFloat32xComplex,     BT uFloat64Complex,     BT uFloat64Complex,
+                                         BT DoubleComplex,       BT DoubleComplex,    BT uFloat64xComplex,    BT uFloat64xComplex,    BT uFloat64xComplex,    BT uFloat128Complex,
+                                      BT uFloat128Complex,    BT uFloat128Complex,   BT LongDoubleComplex,   BT LongDoubleComplex,   BT uFloat128xComplex,   BT uFloat128xComplex,
+                                  },
+                                  {
+                /*   _FX*/           BT uFloat32x,           BT uFloat32x,           BT uFloat32x,           BT uFloat32x,           BT uFloat32x,           BT uFloat32x,
+                                             BT uFloat32x,           BT uFloat32x,           BT uFloat32x,           BT uFloat32x,           BT uFloat32x,           BT uFloat32x,
+                                             BT uFloat32x,           BT uFloat32x,           BT uFloat32x,    BT uFloat32xComplex,           BT uFloat32x,    BT uFloat32xComplex,
+                                             BT uFloat32x,    BT uFloat32xComplex,           BT uFloat32x,    BT uFloat32xComplex,            BT uFloat64,     BT uFloat64Complex,
+                                                BT Double,       BT DoubleComplex,           BT uFloat64x,    BT uFloat64xComplex,           BT uuFloat80,           BT uFloat128,
+                                      BT uFloat128Complex,          BT uuFloat128,          BT LongDouble,   BT LongDoubleComplex,          BT uFloat128x,   BT uFloat128xComplex,
+                                  },
+                                  {
+                /*  _FXC*/    BT uFloat32xComplex,    BT uFloat32xComplex,    BT uFloat32xComplex,    BT uFloat32xComplex,    BT uFloat32xComplex,    BT uFloat32xComplex,
+                                      BT uFloat32xComplex,    BT uFloat32xComplex,    BT uFloat32xComplex,    BT uFloat32xComplex,    BT uFloat32xComplex,    BT uFloat32xComplex,
+                                      BT uFloat32xComplex,    BT uFloat32xComplex,    BT uFloat32xComplex,    BT uFloat32xComplex,    BT uFloat32xComplex,    BT uFloat32xComplex,
+                                      BT uFloat32xComplex,    BT uFloat32xComplex,    BT uFloat32xComplex,    BT uFloat32xComplex,     BT uFloat64Complex,     BT uFloat64Complex,
+                                         BT DoubleComplex,       BT DoubleComplex,    BT uFloat64xComplex,    BT uFloat64xComplex,    BT uFloat64xComplex,    BT uFloat128Complex,
+                                      BT uFloat128Complex,    BT uFloat128Complex,   BT LongDoubleComplex,   BT LongDoubleComplex,   BT uFloat128xComplex,   BT uFloat128xComplex,
+                                  },
+                                  {
+                /*    FD*/            BT uFloat64,            BT uFloat64,            BT uFloat64,            BT uFloat64,            BT uFloat64,            BT uFloat64,
+                                              BT uFloat64,            BT uFloat64,            BT uFloat64,            BT uFloat64,            BT uFloat64,            BT uFloat64,
+                                              BT uFloat64,            BT uFloat64,            BT uFloat64,     BT uFloat64Complex,            BT uFloat64,     BT uFloat64Complex,
+                                              BT uFloat64,     BT uFloat64Complex,            BT uFloat64,     BT uFloat64Complex,            BT uFloat64,     BT uFloat64Complex,
+                                                BT Double,       BT DoubleComplex,           BT uFloat64x,    BT uFloat64xComplex,           BT uuFloat80,           BT uFloat128,
+                                      BT uFloat128Complex,          BT uuFloat128,          BT LongDouble,   BT LongDoubleComplex,          BT uFloat128x,   BT uFloat128xComplex,
+                                  },
+                                  {
+                /*  _FDC*/     BT uFloat64Complex,     BT uFloat64Complex,     BT uFloat64Complex,     BT uFloat64Complex,     BT uFloat64Complex,     BT uFloat64Complex,
+                                       BT uFloat64Complex,     BT uFloat64Complex,     BT uFloat64Complex,     BT uFloat64Complex,     BT uFloat64Complex,     BT uFloat64Complex,
+                                       BT uFloat64Complex,     BT uFloat64Complex,     BT uFloat64Complex,     BT uFloat64Complex,     BT uFloat64Complex,     BT uFloat64Complex,
+                                       BT uFloat64Complex,     BT uFloat64Complex,     BT uFloat64Complex,     BT uFloat64Complex,     BT uFloat64Complex,     BT uFloat64Complex,
+                                         BT DoubleComplex,       BT DoubleComplex,    BT uFloat64xComplex,    BT uFloat64xComplex,    BT uFloat64xComplex,    BT uFloat128Complex,
+                                      BT uFloat128Complex,    BT uFloat128Complex,   BT LongDoubleComplex,   BT LongDoubleComplex,   BT uFloat128xComplex,   BT uFloat128xComplex,
+                                  },
+                                  {
+                /*     D*/              BT Double,              BT Double,              BT Double,              BT Double,              BT Double,              BT Double,
+                                                BT Double,              BT Double,              BT Double,              BT Double,              BT Double,              BT Double,
+                                                BT Double,              BT Double,              BT Double,       BT DoubleComplex,              BT Double,       BT DoubleComplex,
+                                                BT Double,       BT DoubleComplex,              BT Double,       BT DoubleComplex,              BT Double,       BT DoubleComplex,
+                                                BT Double,       BT DoubleComplex,           BT uFloat64x,    BT uFloat64xComplex,           BT uuFloat80,           BT uFloat128,
+                                      BT uFloat128Complex,          BT uuFloat128,          BT LongDouble,   BT LongDoubleComplex,          BT uFloat128x,   BT uFloat128xComplex,
+                                  },
+                                  {
+                /*    DC*/       BT DoubleComplex,       BT DoubleComplex,       BT DoubleComplex,       BT DoubleComplex,       BT DoubleComplex,       BT DoubleComplex,
+                                         BT DoubleComplex,       BT DoubleComplex,       BT DoubleComplex,       BT DoubleComplex,       BT DoubleComplex,       BT DoubleComplex,
+                                         BT DoubleComplex,       BT DoubleComplex,       BT DoubleComplex,       BT DoubleComplex,       BT DoubleComplex,       BT DoubleComplex,
+                                         BT DoubleComplex,       BT DoubleComplex,       BT DoubleComplex,       BT DoubleComplex,       BT DoubleComplex,       BT DoubleComplex,
+                                         BT DoubleComplex,       BT DoubleComplex,    BT uFloat64xComplex,    BT uFloat64xComplex,    BT uFloat64xComplex,    BT uFloat128Complex,
+                                      BT uFloat128Complex,    BT uFloat128Complex,   BT LongDoubleComplex,   BT LongDoubleComplex,   BT uFloat128xComplex,   BT uFloat128xComplex,
+                                  },
+                                  {
+                /*  F80X*/           BT uFloat64x,           BT uFloat64x,           BT uFloat64x,           BT uFloat64x,           BT uFloat64x,           BT uFloat64x,
+                                             BT uFloat64x,           BT uFloat64x,           BT uFloat64x,           BT uFloat64x,           BT uFloat64x,           BT uFloat64x,
+                                             BT uFloat64x,           BT uFloat64x,           BT uFloat64x,    BT uFloat64xComplex,           BT uFloat64x,    BT uFloat64xComplex,
+                                             BT uFloat64x,    BT uFloat64xComplex,           BT uFloat64x,    BT uFloat64xComplex,           BT uFloat64x,    BT uFloat64xComplex,
+                                             BT uFloat64x,    BT uFloat64xComplex,           BT uFloat64x,    BT uFloat64xComplex,           BT uuFloat80,           BT uFloat128,
+                                      BT uFloat128Complex,          BT uuFloat128,          BT LongDouble,   BT LongDoubleComplex,          BT uFloat128x,   BT uFloat128xComplex,
+                                  },
+                                  {
+                /* _FDXC*/    BT uFloat64xComplex,    BT uFloat64xComplex,    BT uFloat64xComplex,    BT uFloat64xComplex,    BT uFloat64xComplex,    BT uFloat64xComplex,
+                                      BT uFloat64xComplex,    BT uFloat64xComplex,    BT uFloat64xComplex,    BT uFloat64xComplex,    BT uFloat64xComplex,    BT uFloat64xComplex,
+                                      BT uFloat64xComplex,    BT uFloat64xComplex,    BT uFloat64xComplex,    BT uFloat64xComplex,    BT uFloat64xComplex,    BT uFloat64xComplex,
+                                      BT uFloat64xComplex,    BT uFloat64xComplex,    BT uFloat64xComplex,    BT uFloat64xComplex,    BT uFloat64xComplex,    BT uFloat64xComplex,
+                                      BT uFloat64xComplex,    BT uFloat64xComplex,    BT uFloat64xComplex,    BT uFloat64xComplex,    BT uFloat64xComplex,    BT uFloat128Complex,
+                                      BT uFloat128Complex,    BT uFloat128Complex,   BT LongDoubleComplex,   BT LongDoubleComplex,   BT uFloat128xComplex,   BT uFloat128xComplex,
+                                  },
+                                  {
+                /*   F80*/           BT uuFloat80,           BT uuFloat80,           BT uuFloat80,           BT uuFloat80,           BT uuFloat80,           BT uuFloat80,
+                                             BT uuFloat80,           BT uuFloat80,           BT uuFloat80,           BT uuFloat80,           BT uuFloat80,           BT uuFloat80,
+                                             BT uuFloat80,           BT uuFloat80,           BT uuFloat80,    BT uFloat64xComplex,           BT uuFloat80,    BT uFloat64xComplex,
+                                             BT uuFloat80,    BT uFloat64xComplex,           BT uuFloat80,    BT uFloat64xComplex,           BT uuFloat80,    BT uFloat64xComplex,
+                                             BT uuFloat80,    BT uFloat64xComplex,           BT uuFloat80,    BT uFloat64xComplex,           BT uuFloat80,           BT uFloat128,
+                                      BT uFloat128Complex,          BT uuFloat128,          BT LongDouble,   BT LongDoubleComplex,          BT uFloat128x,   BT uFloat128xComplex,
+                                  },
+                                  {
+                /*   _FB*/           BT uFloat128,           BT uFloat128,           BT uFloat128,           BT uFloat128,           BT uFloat128,           BT uFloat128,
+                                             BT uFloat128,           BT uFloat128,           BT uFloat128,           BT uFloat128,           BT uFloat128,           BT uFloat128,
+                                             BT uFloat128,           BT uFloat128,           BT uFloat128,    BT uFloat128Complex,           BT uFloat128,    BT uFloat128Complex,
+                                             BT uFloat128,    BT uFloat128Complex,           BT uFloat128,    BT uFloat128Complex,           BT uFloat128,    BT uFloat128Complex,
+                                             BT uFloat128,    BT uFloat128Complex,           BT uFloat128,    BT uFloat128Complex,           BT uFloat128,           BT uFloat128,
+                                      BT uFloat128Complex,          BT uuFloat128,          BT LongDouble,   BT LongDoubleComplex,          BT uFloat128x,   BT uFloat128xComplex,
+                                  },
+                                  {
+                /* _FLDC*/    BT uFloat128Complex,    BT uFloat128Complex,    BT uFloat128Complex,    BT uFloat128Complex,    BT uFloat128Complex,    BT uFloat128Complex,
+                                      BT uFloat128Complex,    BT uFloat128Complex,    BT uFloat128Complex,    BT uFloat128Complex,    BT uFloat128Complex,    BT uFloat128Complex,
+                                      BT uFloat128Complex,    BT uFloat128Complex,    BT uFloat128Complex,    BT uFloat128Complex,    BT uFloat128Complex,    BT uFloat128Complex,
+                                      BT uFloat128Complex,    BT uFloat128Complex,    BT uFloat128Complex,    BT uFloat128Complex,    BT uFloat128Complex,    BT uFloat128Complex,
+                                      BT uFloat128Complex,    BT uFloat128Complex,    BT uFloat128Complex,    BT uFloat128Complex,    BT uFloat128Complex,    BT uFloat128Complex,
+                                      BT uFloat128Complex,    BT uFloat128Complex,   BT LongDoubleComplex,   BT LongDoubleComplex,   BT uFloat128xComplex,   BT uFloat128xComplex,
+                                  },
+                                  {
+                /*    FB*/          BT uuFloat128,          BT uuFloat128,          BT uuFloat128,          BT uuFloat128,          BT uuFloat128,          BT uuFloat128,
+                                            BT uuFloat128,          BT uuFloat128,          BT uuFloat128,          BT uuFloat128,          BT uuFloat128,          BT uuFloat128,
+                                            BT uuFloat128,          BT uuFloat128,          BT uuFloat128,    BT uFloat128Complex,          BT uuFloat128,    BT uFloat128Complex,
+                                            BT uuFloat128,    BT uFloat128Complex,          BT uuFloat128,    BT uFloat128Complex,          BT uuFloat128,    BT uFloat128Complex,
+                                            BT uuFloat128,    BT uFloat128Complex,          BT uuFloat128,    BT uFloat128Complex,          BT uuFloat128,          BT uuFloat128,
+                                      BT uFloat128Complex,          BT uuFloat128,          BT LongDouble,   BT LongDoubleComplex,          BT uFloat128x,   BT uFloat128xComplex,
+                                  },
+                                  {
+                /*    LD*/          BT LongDouble,          BT LongDouble,          BT LongDouble,          BT LongDouble,          BT LongDouble,          BT LongDouble,
+                                            BT LongDouble,          BT LongDouble,          BT LongDouble,          BT LongDouble,          BT LongDouble,          BT LongDouble,
+                                            BT LongDouble,          BT LongDouble,          BT LongDouble,   BT LongDoubleComplex,          BT LongDouble,   BT LongDoubleComplex,
+                                            BT LongDouble,   BT LongDoubleComplex,          BT LongDouble,   BT LongDoubleComplex,          BT LongDouble,   BT LongDoubleComplex,
+                                            BT LongDouble,   BT LongDoubleComplex,          BT LongDouble,   BT LongDoubleComplex,          BT LongDouble,          BT LongDouble,
+                                     BT LongDoubleComplex,          BT LongDouble,          BT LongDouble,   BT LongDoubleComplex,          BT uFloat128x,   BT uFloat128xComplex,
+                                  },
+                                  {
+                /*   LDC*/   BT LongDoubleComplex,   BT LongDoubleComplex,   BT LongDoubleComplex,   BT LongDoubleComplex,   BT LongDoubleComplex,   BT LongDoubleComplex,
+                                     BT LongDoubleComplex,   BT LongDoubleComplex,   BT LongDoubleComplex,   BT LongDoubleComplex,   BT LongDoubleComplex,   BT LongDoubleComplex,
+                                     BT LongDoubleComplex,   BT LongDoubleComplex,   BT LongDoubleComplex,   BT LongDoubleComplex,   BT LongDoubleComplex,   BT LongDoubleComplex,
+                                     BT LongDoubleComplex,   BT LongDoubleComplex,   BT LongDoubleComplex,   BT LongDoubleComplex,   BT LongDoubleComplex,   BT LongDoubleComplex,
+                                     BT LongDoubleComplex,   BT LongDoubleComplex,   BT LongDoubleComplex,   BT LongDoubleComplex,   BT LongDoubleComplex,   BT LongDoubleComplex,
+                                     BT LongDoubleComplex,   BT LongDoubleComplex,   BT LongDoubleComplex,   BT LongDoubleComplex,   BT uFloat128xComplex,   BT uFloat128xComplex,
+                                  },
+                                  {
+                /*  _FBX*/          BT uFloat128x,          BT uFloat128x,          BT uFloat128x,          BT uFloat128x,          BT uFloat128x,          BT uFloat128x,
+                                            BT uFloat128x,          BT uFloat128x,          BT uFloat128x,          BT uFloat128x,          BT uFloat128x,          BT uFloat128x,
+                                            BT uFloat128x,          BT uFloat128x,          BT uFloat128x,   BT uFloat128xComplex,          BT uFloat128x,   BT uFloat128xComplex,
+                                            BT uFloat128x,   BT uFloat128xComplex,          BT uFloat128x,   BT uFloat128xComplex,          BT uFloat128x,   BT uFloat128xComplex,
+                                            BT uFloat128x,   BT uFloat128xComplex,          BT uFloat128x,   BT uFloat128xComplex,          BT uFloat128x,          BT uFloat128x,
+                                     BT uFloat128xComplex,          BT uFloat128x,          BT uFloat128x,   BT uFloat128xComplex,          BT uFloat128x,   BT uFloat128xComplex,
+                                  },
+                                  {
+                /*_FLDXC*/   BT uFloat128xComplex,   BT uFloat128xComplex,   BT uFloat128xComplex,   BT uFloat128xComplex,   BT uFloat128xComplex,   BT uFloat128xComplex,
+                                     BT uFloat128xComplex,   BT uFloat128xComplex,   BT uFloat128xComplex,   BT uFloat128xComplex,   BT uFloat128xComplex,   BT uFloat128xComplex,
+                                     BT uFloat128xComplex,   BT uFloat128xComplex,   BT uFloat128xComplex,   BT uFloat128xComplex,   BT uFloat128xComplex,   BT uFloat128xComplex,
+                                     BT uFloat128xComplex,   BT uFloat128xComplex,   BT uFloat128xComplex,   BT uFloat128xComplex,   BT uFloat128xComplex,   BT uFloat128xComplex,
+                                     BT uFloat128xComplex,   BT uFloat128xComplex,   BT uFloat128xComplex,   BT uFloat128xComplex,   BT uFloat128xComplex,   BT uFloat128xComplex,
+                                     BT uFloat128xComplex,   BT uFloat128xComplex,   BT uFloat128xComplex,   BT uFloat128xComplex,   BT uFloat128xComplex,   BT uFloat128xComplex,
+                                  },
+        }; // commonTypes
+        #undef BT
+        // GENERATED END
+        static const BasicType::Kind combinedType[][ BasicType::NUMBER_OF_BASIC_TYPES ] =
+        {
+/*              Bool            Char    SignedChar      UnsignedChar    ShortSignedInt  ShortUnsignedInt        SignedInt       UnsignedInt     LongSignedInt   LongUnsignedInt LongLongSignedInt       LongLongUnsignedInt     Float   Double  LongDouble      FloatComplex    DoubleComplex   LongDoubleComplex       FloatImaginary  DoubleImaginary LongDoubleImaginary   SignedInt128   UnsignedInt128   Float80   Float128 */
+                /* Bool */      { BasicType::Bool,              BasicType::Char,        BasicType::SignedChar,  BasicType::UnsignedChar,        BasicType::ShortSignedInt,      BasicType::ShortUnsignedInt,    BasicType::SignedInt,   BasicType::UnsignedInt, BasicType::LongSignedInt,       BasicType::LongUnsignedInt,     BasicType::LongLongSignedInt,   BasicType::LongLongUnsignedInt, BasicType::Float,       BasicType::Double,      BasicType::LongDouble,  BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::SignedInt128,        BasicType::UnsignedInt128, BasicType::Float80, BasicType::Float128 },
+                /* Char */      { BasicType::Char,              BasicType::Char,        BasicType::UnsignedChar,        BasicType::UnsignedChar,        BasicType::ShortSignedInt,      BasicType::ShortUnsignedInt,    BasicType::SignedInt,   BasicType::UnsignedInt, BasicType::LongSignedInt,       BasicType::LongUnsignedInt,     BasicType::LongLongSignedInt,   BasicType::LongLongUnsignedInt, BasicType::Float,       BasicType::Double,      BasicType::LongDouble,  BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::SignedInt128,        BasicType::UnsignedInt128, BasicType::Float80, BasicType::Float128 },
+                /* SignedChar */        { BasicType::SignedChar,        BasicType::UnsignedChar,        BasicType::SignedChar,  BasicType::UnsignedChar,        BasicType::ShortSignedInt,      BasicType::ShortUnsignedInt,    BasicType::SignedInt,   BasicType::UnsignedInt, BasicType::LongSignedInt,       BasicType::LongUnsignedInt,     BasicType::LongLongSignedInt,   BasicType::LongLongUnsignedInt, BasicType::Float,       BasicType::Double,      BasicType::LongDouble,  BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::SignedInt128,        BasicType::UnsignedInt128, BasicType::Float80, BasicType::Float128 },
+                /* UnsignedChar */      { BasicType::UnsignedChar,      BasicType::UnsignedChar,        BasicType::UnsignedChar,        BasicType::UnsignedChar,        BasicType::ShortSignedInt,      BasicType::ShortUnsignedInt,    BasicType::SignedInt,   BasicType::UnsignedInt, BasicType::LongSignedInt,       BasicType::LongUnsignedInt,     BasicType::LongLongSignedInt,   BasicType::LongLongUnsignedInt, BasicType::Float,       BasicType::Double,      BasicType::LongDouble,  BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::SignedInt128,        BasicType::UnsignedInt128, BasicType::Float80, BasicType::Float128 },
+                /* ShortSignedInt */    { BasicType::ShortSignedInt,    BasicType::ShortSignedInt,      BasicType::ShortSignedInt,      BasicType::ShortSignedInt,      BasicType::ShortSignedInt,      BasicType::ShortUnsignedInt,    BasicType::SignedInt,   BasicType::UnsignedInt, BasicType::LongSignedInt,       BasicType::LongUnsignedInt,     BasicType::LongLongSignedInt,   BasicType::LongLongUnsignedInt, BasicType::Float,       BasicType::Double,      BasicType::LongDouble,  BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::SignedInt128,        BasicType::UnsignedInt128, BasicType::Float80, BasicType::Float128 },
+                /* ShortUnsignedInt */  { BasicType::ShortUnsignedInt,  BasicType::ShortUnsignedInt,    BasicType::ShortUnsignedInt,    BasicType::ShortUnsignedInt,    BasicType::ShortUnsignedInt,    BasicType::ShortUnsignedInt,    BasicType::SignedInt,   BasicType::UnsignedInt, BasicType::LongSignedInt,       BasicType::LongUnsignedInt,     BasicType::LongLongSignedInt,   BasicType::LongLongUnsignedInt, BasicType::Float,       BasicType::Double,      BasicType::LongDouble,  BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::SignedInt128,        BasicType::UnsignedInt128, BasicType::Float80, BasicType::Float128 },
+                /* SignedInt */         { BasicType::SignedInt,         BasicType::SignedInt,   BasicType::SignedInt,   BasicType::SignedInt,   BasicType::SignedInt,   BasicType::SignedInt,   BasicType::SignedInt,   BasicType::UnsignedInt, BasicType::LongSignedInt,       BasicType::LongUnsignedInt,     BasicType::LongLongSignedInt,   BasicType::LongLongUnsignedInt, BasicType::Float,       BasicType::Double,      BasicType::LongDouble,  BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::SignedInt128,        BasicType::UnsignedInt128, BasicType::Float80, BasicType::Float128 },
+                /* UnsignedInt */       { BasicType::UnsignedInt,               BasicType::UnsignedInt, BasicType::UnsignedInt, BasicType::UnsignedInt, BasicType::UnsignedInt, BasicType::UnsignedInt, BasicType::UnsignedInt, BasicType::UnsignedInt, BasicType::LongUnsignedInt,     BasicType::LongUnsignedInt,     BasicType::LongLongSignedInt,   BasicType::LongLongUnsignedInt, BasicType::Float,       BasicType::Double,      BasicType::LongDouble,  BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::SignedInt128,        BasicType::UnsignedInt128, BasicType::Float80, BasicType::Float128 },
+                /* LongSignedInt */     { BasicType::LongSignedInt,             BasicType::LongSignedInt,       BasicType::LongSignedInt,       BasicType::LongSignedInt,       BasicType::LongSignedInt,       BasicType::LongSignedInt,       BasicType::LongSignedInt,       BasicType::LongUnsignedInt,     BasicType::LongSignedInt,       BasicType::LongUnsignedInt,     BasicType::LongLongSignedInt,   BasicType::LongLongUnsignedInt, BasicType::Float,       BasicType::Double,      BasicType::LongDouble,  BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::SignedInt128,        BasicType::UnsignedInt128, BasicType::Float80, BasicType::Float128 },
+                /* LongUnsignedInt */   { BasicType::LongUnsignedInt,   BasicType::LongUnsignedInt,     BasicType::LongUnsignedInt,     BasicType::LongUnsignedInt,     BasicType::LongUnsignedInt,     BasicType::LongUnsignedInt,     BasicType::LongUnsignedInt,     BasicType::LongUnsignedInt,     BasicType::LongUnsignedInt,     BasicType::LongUnsignedInt,     BasicType::LongLongSignedInt,   BasicType::LongLongUnsignedInt, BasicType::Float,       BasicType::Double,      BasicType::LongDouble,  BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::SignedInt128,        BasicType::UnsignedInt128, BasicType::Float80, BasicType::Float128 },
+                /* LongLongSignedInt */         { BasicType::LongLongSignedInt, BasicType::LongLongSignedInt,   BasicType::LongLongSignedInt,   BasicType::LongLongSignedInt,   BasicType::LongLongSignedInt,   BasicType::LongLongSignedInt,   BasicType::LongLongSignedInt,   BasicType::LongLongSignedInt,   BasicType::LongLongSignedInt,   BasicType::LongLongSignedInt,   BasicType::LongLongSignedInt,   BasicType::LongLongUnsignedInt, BasicType::Float,       BasicType::Double,      BasicType::LongDouble,  BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::SignedInt128,        BasicType::UnsignedInt128, BasicType::Float80, BasicType::Float128 },
+                /* LongLongUnsignedInt */       { BasicType::LongLongUnsignedInt,       BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::Float,       BasicType::Double,      BasicType::LongDouble,  BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::SignedInt128,        BasicType::UnsignedInt128, BasicType::Float80, BasicType::Float128 },
+                /* Float */     { BasicType::Float,     BasicType::Float,       BasicType::Float,       BasicType::Float,       BasicType::Float,       BasicType::Float,       BasicType::Float,       BasicType::Float,       BasicType::Float,       BasicType::Float,       BasicType::Float,       BasicType::Float,       BasicType::Float,       BasicType::Double,      BasicType::LongDouble,  BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::Float,       BasicType::Float, BasicType::Float80, BasicType::Float128 },
+                /* Double */    { BasicType::Double,    BasicType::Double,      BasicType::Double,      BasicType::Double,      BasicType::Double,      BasicType::Double,      BasicType::Double,      BasicType::Double,      BasicType::Double,      BasicType::Double,      BasicType::Double,      BasicType::Double,      BasicType::Double,      BasicType::Double,      BasicType::LongDouble,  BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::Double,      BasicType::Double, BasicType::Float80, BasicType::Float128 },
+                /* LongDouble */        { BasicType::LongDouble,                BasicType::LongDouble,  BasicType::LongDouble,  BasicType::LongDouble,  BasicType::LongDouble,  BasicType::LongDouble,  BasicType::LongDouble,  BasicType::LongDouble,  BasicType::LongDouble,  BasicType::LongDouble,  BasicType::LongDouble,  BasicType::LongDouble,  BasicType::LongDouble,  BasicType::LongDouble,  BasicType::LongDouble,  BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDouble,  BasicType::LongDouble, BasicType::BasicType::LongDouble, BasicType::Float128 },
+                /* FloatComplex */      { BasicType::FloatComplex,      BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::FloatComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, },
+                /* DoubleComplex */     { BasicType::DoubleComplex,     BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::DoubleComplex,       BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex },
+                /* LongDoubleComplex */         { BasicType::LongDoubleComplex, BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, },
+                /* FloatImaginary */    { BasicType::FloatComplex,      BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatImaginary,      BasicType::DoubleImaginary,     BasicType::LongDoubleImaginary, BasicType::FloatImaginary,      BasicType::FloatImaginary, BasicType::LongDoubleImaginary, BasicType::LongDoubleImaginary, },
+                /* DoubleImaginary */   { BasicType::DoubleComplex,     BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::DoubleImaginary,     BasicType::DoubleImaginary,     BasicType::LongDoubleImaginary, BasicType::DoubleImaginary,     BasicType::DoubleImaginary, BasicType::LongDoubleImaginary, BasicType::LongDoubleImaginary, },
+                /* LongDoubleImaginary */       { BasicType::LongDoubleComplex, BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleImaginary, BasicType::LongDoubleImaginary, BasicType::LongDoubleImaginary, BasicType::LongDoubleImaginary, BasicType::LongDoubleImaginary, },
+                /* SignedInt128 */      { BasicType::SignedInt128,      BasicType::SignedInt128,        BasicType::SignedInt128,        BasicType::SignedInt128,        BasicType::SignedInt128,        BasicType::SignedInt128,        BasicType::SignedInt128,        BasicType::SignedInt128,        BasicType::SignedInt128,        BasicType::SignedInt128,        BasicType::SignedInt128,        BasicType::SignedInt128,        BasicType::Float,       BasicType::Double,      BasicType::LongDouble,  BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::SignedInt128,        BasicType::UnsignedInt128, BasicType::Float80, BasicType::Float128, },
+                /* UnsignedInt128 */    { BasicType::UnsignedInt128,    BasicType::UnsignedInt128,      BasicType::UnsignedInt128,      BasicType::UnsignedInt128,      BasicType::UnsignedInt128,      BasicType::UnsignedInt128,      BasicType::UnsignedInt128,      BasicType::UnsignedInt128,      BasicType::UnsignedInt128,      BasicType::UnsignedInt128,      BasicType::UnsignedInt128,      BasicType::UnsignedInt128,      BasicType::Float,       BasicType::Double,      BasicType::LongDouble,  BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::UnsignedInt128,      BasicType::UnsignedInt128, BasicType::Float80, BasicType::Float128, },
+                /* Float80 */   { BasicType::Float80,   BasicType::Float80,     BasicType::Float80,     BasicType::Float80,     BasicType::Float80,     BasicType::Float80,     BasicType::Float80,     BasicType::Float80,     BasicType::Float80,     BasicType::Float80,     BasicType::Float80,     BasicType::Float80,     BasicType::Float80,     BasicType::Float80,     BasicType::LongDouble,  BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::Float80,     BasicType::Float80, BasicType::Float80, BasicType::Float128 },
+                /* Float128 */  { BasicType::Float128,  BasicType::Float128,    BasicType::Float128,    BasicType::Float128,    BasicType::Float128,    BasicType::Float128,    BasicType::Float128,    BasicType::Float128,    BasicType::Float128,    BasicType::Float128,    BasicType::Float128,    BasicType::Float128,    BasicType::Float128,    BasicType::Float128,    BasicType::Float128,    BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::Float128,    BasicType::Float128, BasicType::Float128, BasicType::Float128 },
+        };
         static_assert(
                 sizeof(commonTypes)/sizeof(commonTypes[0][0]) == BasicType::NUMBER_OF_BASIC_TYPES*BasicType::NUMBER_OF_BASIC_TYPES,
+                sizeof(combinedType)/sizeof(combinedType[0][0]) == BasicType::NUMBER_OF_BASIC_TYPES*BasicType::NUMBER_OF_BASIC_TYPES,
                 "Each basic type kind should have a corresponding row in the combined type matrix"
         );
 …
         void CommonType::postvisit( BasicType *basicType ) {
                 if ( BasicType *otherBasic = dynamic_cast< BasicType* >( type2 ) ) {
                         BasicType::Kind newType = commonTypes[ basicType->get_kind() ][ otherBasic->get_kind() ];
+                        BasicType::Kind newType = combinedType[ basicType->get_kind() ][ otherBasic->get_kind() ];
                         if ( ( ( newType == basicType->get_kind() && basicType->get_qualifiers() >= otherBasic->get_qualifiers() ) || widenFirst ) && ( ( newType == otherBasic->get_kind() && basicType->get_qualifiers() <= otherBasic->get_qualifiers() ) || widenSecond ) ) {
                                 result = new BasicType( basicType->get_qualifiers() | otherBasic->get_qualifiers(), newType );
 …
                 } else if ( dynamic_cast< EnumInstType * > ( type2 ) || dynamic_cast< ZeroType* >( type2 ) || dynamic_cast< OneType* >( type2 ) ) {
                         // use signed int in lieu of the enum/zero/one type
                         BasicType::Kind newType = commonTypes[ basicType->get_kind() ][ BasicType::SignedInt ];
+                        BasicType::Kind newType = combinedType[ basicType->get_kind() ][ BasicType::SignedInt ];
                         if ( ( ( newType == basicType->get_kind() && basicType->get_qualifiers() >= type2->get_qualifiers() ) || widenFirst ) && ( ( newType != basicType->get_kind() && basicType->get_qualifiers() <= type2->get_qualifiers() ) || widenSecond ) ) {
                                 result = new BasicType( basicType->get_qualifiers() | type2->get_qualifiers(), newType );

src/ResolvExpr/ConversionCost.cc

-              r933f32f
+              r6a9d4b4
 // Created On       : Sun May 17 07:06:19 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Mon May  6 14:18:22 2019
 // Update Count     : 25
+// Last Modified On : Mon Sep 25 15:43:34 2017
+// Update Count     : 10
 //
 …
 namespace ResolvExpr {
+#if 0
+        const Cost Cost::zero =      Cost{  0,  0,  0,  0,  0,  0,  0 };
+        const Cost Cost::infinity =  Cost{ -1, -1, -1, -1, -1,  1, -1 };
+        const Cost Cost::unsafe =    Cost{  1,  0,  0,  0,  0,  0,  0 };
+        const Cost Cost::poly =      Cost{  0,  1,  0,  0,  0,  0,  0 };
+        const Cost Cost::safe =      Cost{  0,  0,  1,  0,  0,  0,  0 };
+        const Cost Cost::sign =      Cost{  0,  0,  0,  1,  0,  0,  0 };
+        const Cost Cost::var =       Cost{  0,  0,  0,  0,  1,  0,  0 };
+        const Cost Cost::spec =      Cost{  0,  0,  0,  0,  0, -1,  0 };
+        const Cost Cost::reference = Cost{  0,  0,  0,  0,  0,  0,  1 };
+#endif
+        const Cost Cost::zero =      Cost{  0,  0,  0,  0,  0,  0 };
+        const Cost Cost::infinity =  Cost{ -1, -1, -1, -1,  1, -1 };
+        const Cost Cost::unsafe =    Cost{  1,  0,  0,  0,  0,  0 };
+        const Cost Cost::poly =      Cost{  0,  1,  0,  0,  0,  0 };
+        const Cost Cost::safe =      Cost{  0,  0,  1,  0,  0,  0 };
+        const Cost Cost::var =       Cost{  0,  0,  0,  1,  0,  0 };
+        const Cost Cost::spec =      Cost{  0,  0,  0,  0, -1,  0 };
+        const Cost Cost::reference = Cost{  0,  0,  0,  0,  0,  1 };
 #if 0
 …
 #define PRINT(x)
 #endif
         Cost conversionCost( Type *src, Type *dest, const SymTab::Indexer &indexer, const TypeEnvironment &env ) {
                 if ( TypeInstType *destAsTypeInst = dynamic_cast< TypeInstType* >( dest ) ) {
 …
+        }
+        // GENERATED START, DO NOT EDIT
+        // GENERATED BY BasicTypes-gen.cc
+        /* EXTENDED INTEGRAL RANK HIERARCHY (root to leaves)
+                                 _Bool
+        char                signed char         unsigned char
+                  signed short int         unsigned short int
+                  signed int               unsigned int
+                  signed long int          unsigned long int
+                  signed long long int     unsigned long long int
+                  __int128                 unsigned __int128
+                  _Float16                 _Float16 _Complex
+                  _Float32                 _Float32 _Complex
+                  float                    float _Complex
+                  _Float32x                _Float32x _Complex
+                  _Float64                 _Float64 _Complex
+                  double                   double _Complex
+                  _Float64x                _Float64x _Complex
+                             __float80
+                  _Float128                _Float128 _Complex
+                            __float128
+                  long double              long double _Complex
+                  _Float128x               _Float128x _Complex
+        */
+        // GENERATED END
+        // GENERATED START, DO NOT EDIT
+        // GENERATED BY BasicTypes-gen.cc
+        static const int costMatrix[BasicType::NUMBER_OF_BASIC_TYPES][BasicType::NUMBER_OF_BASIC_TYPES] = { // path length from root to node
+                /*             B    C   SC   UC   SI  SUI    I   UI   LI  LUI  LLI LLUI   IB  UIB  _FH  _FH   _F  _FC    F   FC  _FX _FXC   FD _FDC    D   DC F80X_FDXC  F80  _FB_FLDC   FB   LD  LDC _FBX_FLDXC */
+                /*     B*/ {   0,   1,   1,   2,   2,   3,   3,   4,   4,   5,   5,   6,   6,   7,   7,   8,   8,   9,   9,  10,  10,  11,  11,  12,  12,  13,  13,  14,  14,  15,  15,  16,  17,  16,  18,  17, },
+                /*     C*/ {  -1,   0,   1,   1,   1,   2,   2,   3,   3,   4,   4,   5,   5,   6,   6,   7,   7,   8,   8,   9,   9,  10,  10,  11,  11,  12,  12,  13,  13,  14,  14,  15,  16,  15,  17,  16, },
+                /*    SC*/ {  -1,  -1,   0,   1,   1,   2,   2,   3,   3,   4,   4,   5,   5,   6,   6,   7,   7,   8,   8,   9,   9,  10,  10,  11,  11,  12,  12,  13,  13,  14,  14,  15,  16,  15,  17,  16, },
+                /*    UC*/ {  -1,  -1,  -1,   0,   1,   1,   2,   2,   3,   3,   4,   4,   5,   5,   6,   7,   7,   8,   8,   9,   9,  10,  10,  11,  11,  12,  12,  13,  13,  14,  14,  15,  16,  15,  17,  16, },
+                /*    SI*/ {  -1,  -1,  -1,  -1,   0,   1,   1,   2,   2,   3,   3,   4,   4,   5,   5,   6,   6,   7,   7,   8,   8,   9,   9,  10,  10,  11,  11,  12,  12,  13,  13,  14,  15,  14,  16,  15, },
+                /*   SUI*/ {  -1,  -1,  -1,  -1,  -1,   0,   1,   1,   2,   2,   3,   3,   4,   4,   5,   6,   6,   7,   7,   8,   8,   9,   9,  10,  10,  11,  11,  12,  12,  13,  13,  14,  15,  14,  16,  15, },
+                /*     I*/ {  -1,  -1,  -1,  -1,  -1,  -1,   0,   1,   1,   2,   2,   3,   3,   4,   4,   5,   5,   6,   6,   7,   7,   8,   8,   9,   9,  10,  10,  11,  11,  12,  12,  13,  14,  13,  15,  14, },
+                /*    UI*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   1,   1,   2,   2,   3,   3,   4,   5,   5,   6,   6,   7,   7,   8,   8,   9,   9,  10,  10,  11,  11,  12,  12,  13,  14,  13,  15,  14, },
+                /*    LI*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   1,   1,   2,   2,   3,   3,   4,   4,   5,   5,   6,   6,   7,   7,   8,   8,   9,   9,  10,  10,  11,  11,  12,  13,  12,  14,  13, },
+                /*   LUI*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   1,   1,   2,   2,   3,   4,   4,   5,   5,   6,   6,   7,   7,   8,   8,   9,   9,  10,  10,  11,  11,  12,  13,  12,  14,  13, },
+                /*   LLI*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   1,   1,   2,   2,   3,   3,   4,   4,   5,   5,   6,   6,   7,   7,   8,   8,   9,   9,  10,  10,  11,  12,  11,  13,  12, },
+                /*  LLUI*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   1,   1,   2,   3,   3,   4,   4,   5,   5,   6,   6,   7,   7,   8,   8,   9,   9,  10,  10,  11,  12,  11,  13,  12, },
+                /*    IB*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   1,   1,   2,   2,   3,   3,   4,   4,   5,   5,   6,   6,   7,   7,   8,   8,   9,   9,  10,  11,  10,  12,  11, },
+                /*   UIB*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   1,   2,   2,   3,   3,   4,   4,   5,   5,   6,   6,   7,   7,   8,   8,   9,   9,  10,  11,  10,  12,  11, },
+                /*   _FH*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   1,   1,   2,   2,   3,   3,   4,   4,   5,   5,   6,   6,   7,   7,   8,   8,   9,  10,   9,  11,  10, },
+                /*   _FH*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,  -1,   1,  -1,   2,  -1,   3,  -1,   4,  -1,   5,  -1,   6,  -1,  -1,   7,  -1,  -1,   8,  -1,   9, },
+                /*    _F*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   1,   1,   2,   2,   3,   3,   4,   4,   5,   5,   6,   6,   7,   7,   8,   9,   8,  10,   9, },
+                /*   _FC*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,  -1,   1,  -1,   2,  -1,   3,  -1,   4,  -1,   5,  -1,  -1,   6,  -1,  -1,   7,  -1,   8, },
+                /*     F*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   1,   1,   2,   2,   3,   3,   4,   4,   5,   5,   6,   6,   7,   8,   7,   9,   8, },
+                /*    FC*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,  -1,   1,  -1,   2,  -1,   3,  -1,   4,  -1,  -1,   5,  -1,  -1,   6,  -1,   7, },
+                /*   _FX*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   1,   1,   2,   2,   3,   3,   4,   4,   5,   5,   6,   7,   6,   8,   7, },
+                /*  _FXC*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,  -1,   1,  -1,   2,  -1,   3,  -1,  -1,   4,  -1,  -1,   5,  -1,   6, },
+                /*    FD*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   1,   1,   2,   2,   3,   3,   4,   4,   5,   6,   5,   7,   6, },
+                /*  _FDC*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,  -1,   1,  -1,   2,  -1,  -1,   3,  -1,  -1,   4,  -1,   5, },
+                /*     D*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   1,   1,   2,   2,   3,   3,   4,   5,   4,   6,   5, },
+                /*    DC*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,  -1,   1,  -1,  -1,   2,  -1,  -1,   3,  -1,   4, },
+                /*  F80X*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   1,   1,   2,   2,   3,   4,   3,   5,   4, },
+                /* _FDXC*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,  -1,  -1,   1,  -1,  -1,   2,  -1,   3, },
+                /*   F80*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   1,   0,   1,   2,   2,   3,   3,   4,   4, },
+                /*   _FB*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   1,   1,   2,   2,   3,   3, },
+                /* _FLDC*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,  -1,  -1,   1,  -1,   2, },
+                /*    FB*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   1,   0,   1,   2,   2,   3, },
+                /*    LD*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   1,   1,   2, },
+                /*   LDC*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,  -1,   1, },
+                /*  _FBX*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   1, },
+                /*_FLDXC*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0, },
+        }; // costMatrix
+        static const int maxIntCost = 15;
+        // GENERATED END
+/*
+            Old
+            ===
+           Double
+             |
+           Float
+             |
+           ULong
+           /   \
+        UInt    Long
+           \   /
+            Int
+             |
+           Ushort
+             |
+           Short
+             |
+           Uchar
+           /   \
+        Schar   Char
+                                New
+                                ===
+                       +-----LongDoubleComplex--+
+           LongDouble--+          |             +-LongDoubleImag
+             |         +---DoubleComplex---+         |
+           Double------+        |          +----DoubleImag
+             |           +-FloatComplex-+            |
+           Float---------+              +-------FloatImag
+             |
+          ULongLong
+             |
+          LongLong
+             |
+           ULong
+           /   \
+        UInt    Long
+           \   /
+            Int
+             |
+           Ushort
+             |
+           Short
+             |
+           Uchar
+           /   \
+        Schar   Char
+           \   /
+            Bool
+*/
+        static const int costMatrix[][ BasicType::NUMBER_OF_BASIC_TYPES ] = {
+        /* Src \ Dest:  Bool    Char    SChar   UChar   Short   UShort  Int     UInt    Long    ULong   LLong   ULLong  Float   Double  LDbl    FCplex  DCplex  LDCplex FImag   DImag   LDImag  I128,   U128, F80, F128 */
+                /* Bool */      { 0,    1,              1,              2,              3,              4,              5,              6,              6,              7,              8,              9,              12,             13,             14,             12,             13,             14,             -1,             -1,             -1,             10,             11,       14,   15},
+                /* Char */      { -1,   0,              -1,             1,              2,              3,              4,              5,              5,              6,              7,              8,              11,             12,             13,             11,             12,             13,             -1,             -1,             -1,             9,              10,       13,   14},
+                /* SChar */ { -1,       -1,             0,              1,              2,              3,              4,              5,              5,              6,              7,              8,              11,             12,             13,             11,             12,             13,             -1,             -1,             -1,             9,              10,       13,   14},
+                /* UChar */ { -1,       -1,             -1,             0,              1,              2,              3,              4,              4,              5,              6,              7,              10,             11,             12,             10,             11,             12,             -1,             -1,             -1,             8,              9,        12,   13},
+                /* Short */ { -1,       -1,             -1,             -1,             0,              1,              2,              3,              3,              4,              5,              6,              9,              10,             11,             9,              10,             11,             -1,             -1,             -1,             7,              8,        11,   12},
+                /* UShort */{ -1,       -1,             -1,             -1,             -1,             0,              1,              2,              2,              3,              4,              5,              8,              9,              10,             8,              9,              10,             -1,             -1,             -1,             6,              7,        10,   11},
+                /* Int */       { -1,   -1,             -1,             -1,             -1,             -1,             0,              1,              1,              2,              3,              4,              7,              8,              9,              7,              8,              9,              -1,             -1,             -1,             5,              6,        9,    10},
+                /* UInt */      { -1,   -1,             -1,             -1,             -1,             -1,             -1,             0,              -1,             1,              2,              3,              6,              7,              8,              6,              7,              8,              -1,             -1,             -1,             4,              5,        8,    9},
+                /* Long */      { -1,   -1,             -1,             -1,             -1,             -1,             -1,             -1,             0,              1,              2,              3,              6,              7,              8,              6,              7,              8,              -1,             -1,             -1,             4,              5,        8,    9},
+                /* ULong */ { -1,       -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             0,              1,              2,              5,              6,              7,              5,              6,              7,              -1,             -1,             -1,             3,              4,        7,    8},
+                /* LLong */ { -1,       -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             0,              1,              4,              5,              6,              4,              5,              6,              -1,             -1,             -1,             2,              3,        6,    7},
+                /* ULLong */{ -1,       -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             0,              3,              4,              5,              3,              4,              5,              -1,             -1,             -1,             1,              2,        5,    6},
+                /* Float */ { -1,       -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             0,              1,              2,              1,              2,              3,              -1,             -1,             -1,             -1,             -1,       2,    3},
+                /* Double */{ -1,       -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             0,              1,              -1,             1,              2,              -1,             -1,             -1,             -1,             -1,       1,    2},
+                /* LDbl */      { -1,   -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             0,              -1,             -1,             1,              -1,             -1,             -1,             -1,             -1,       -1,   1},
+                /* FCplex */{ -1,       -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             0,              1,              2,              -1,             -1,             -1,             -1,             -1,       -1,   -1},
+                /* DCplex */{ -1,       -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             0,              1,              -1,             -1,             -1,             -1,             -1,       -1,   -1},
+                /* LDCplex */{ -1,      -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             0,              -1,             -1,             -1,             -1,             -1,       -1,   -1},
+                /* FImag */ { -1,       -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             1,              2,              3,              0,              1,              2,              -1,             -1,       -1,   -1},
+                /* DImag */ { -1,       -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             1,              2,              -1,             0,              1,              -1,             -1,       -1,   -1},
+                /* LDImag */{ -1,       -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             1,              -1,             -1,             0,              -1,             -1,       -1,   -1},
+                /* I128 */  { -1,       -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             2,              3,              4,              3,              4,              5,              -1,             -1,             -1,             0,              1,        4,    4},
+                /* U128 */  { -1,       -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             1,              2,              3,              2,              3,              4,              -1,             -1,             -1,             -1,             0,        3,    3},
+                /* F80 */       { -1,   -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             1,              -1,             -1,             1,              -1,             -1,             -1,             -1,             -1,       0,    1},
+                /* F128 */      { -1,   -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             1,              -1,             -1,             -1,             -1,             -1,       -1,   0},
+        };
         static_assert(
                 sizeof(costMatrix)/sizeof(costMatrix[0][0]) == BasicType::NUMBER_OF_BASIC_TYPES*BasicType::NUMBER_OF_BASIC_TYPES,
                 "Missing row in the cost matrix"
+                "Each basic type kind should have a corresponding row in the cost matrix"
         );
-        // GENERATED START, DO NOT EDIT
-        // GENERATED BY BasicTypes-gen.cc
-        static const int signMatrix[BasicType::NUMBER_OF_BASIC_TYPES][BasicType::NUMBER_OF_BASIC_TYPES] = { // number of sign changes in safe conversion
-                /*             B    C   SC   UC   SI  SUI    I   UI   LI  LUI  LLI LLUI   IB  UIB  _FH  _FH   _F  _FC    F   FC  _FX _FXC   FD _FDC    D   DC F80X_FDXC  F80  _FB_FLDC   FB   LD  LDC _FBX_FLDXC */
-                /*     B*/ {   0,   0,   0,   1,   0,   1,   0,   1,   0,   1,   0,   1,   0,   1,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, },
-                /*     C*/ {  -1,   0,   0,   1,   0,   1,   0,   1,   0,   1,   0,   1,   0,   1,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, },
-                /*    SC*/ {  -1,  -1,   0,   1,   0,   1,   0,   1,   0,   1,   0,   1,   0,   1,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, },
-                /*    UC*/ {  -1,  -1,  -1,   0,   1,   0,   1,   0,   1,   0,   1,   0,   1,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, },
-                /*    SI*/ {  -1,  -1,  -1,  -1,   0,   1,   0,   1,   0,   1,   0,   1,   0,   1,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, },
-                /*   SUI*/ {  -1,  -1,  -1,  -1,  -1,   0,   1,   0,   1,   0,   1,   0,   1,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, },
-                /*     I*/ {  -1,  -1,  -1,  -1,  -1,  -1,   0,   1,   0,   1,   0,   1,   0,   1,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, },
-                /*    UI*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   1,   0,   1,   0,   1,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, },
-                /*    LI*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   1,   0,   1,   0,   1,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, },
-                /*   LUI*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   1,   0,   1,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, },
-                /*   LLI*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   1,   0,   1,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, },
-                /*  LLUI*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   1,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, },
-                /*    IB*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   1,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, },
-                /*   UIB*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, },
-                /*   _FH*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, },
-                /*   _FH*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,  -1,   0,  -1,   0,  -1,   0,  -1,   0,  -1,   0,  -1,   0,  -1,  -1,   0,  -1,  -1,   0,  -1,   0, },
-                /*    _F*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, },
-                /*   _FC*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,  -1,   0,  -1,   0,  -1,   0,  -1,   0,  -1,   0,  -1,  -1,   0,  -1,  -1,   0,  -1,   0, },
-                /*     F*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, },
-                /*    FC*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,  -1,   0,  -1,   0,  -1,   0,  -1,   0,  -1,  -1,   0,  -1,  -1,   0,  -1,   0, },
-                /*   _FX*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, },
-                /*  _FXC*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,  -1,   0,  -1,   0,  -1,   0,  -1,  -1,   0,  -1,  -1,   0,  -1,   0, },
-                /*    FD*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, },
-                /*  _FDC*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,  -1,   0,  -1,   0,  -1,  -1,   0,  -1,  -1,   0,  -1,   0, },
-                /*     D*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, },
-                /*    DC*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,  -1,   0,  -1,  -1,   0,  -1,  -1,   0,  -1,   0, },
-                /*  F80X*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, },
-                /* _FDXC*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,  -1,  -1,   0,  -1,  -1,   0,  -1,   0, },
-                /*   F80*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   0,   0,   0,   0,   0,   0,   0,   0, },
-                /*   _FB*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   0,   0,   0,   0,   0,   0, },
-                /* _FLDC*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,  -1,  -1,   0,  -1,   0, },
-                /*    FB*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   0,   0,   0,   0,   0, },
-                /*    LD*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   0,   0,   0, },
-                /*   LDC*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,  -1,   0, },
-                /*  _FBX*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   0, },
-                /*_FLDXC*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0, },
-        }; // signMatrix
-        // GENERATED END
-        static_assert(
-                sizeof(signMatrix)/sizeof(signMatrix[0][0]) == BasicType::NUMBER_OF_BASIC_TYPES*BasicType::NUMBER_OF_BASIC_TYPES,
-                "Missing row in the sign matrix"
-        );
         void ConversionCost::postvisit( VoidType * ) {
 …
                                 cost = Cost::zero;
                                 cost.incSafe( tableResult );
-                                cost.incSign( signMatrix[ basicType->get_kind() ][ destAsBasic->get_kind() ] );
                         } // if
                 } else if ( dynamic_cast< EnumInstType *>( dest ) ) {
 …
                                         // types are the same, except otherPointer has more qualifiers
                                         cost = Cost::safe;
                                 } // if
+                                }
                         } else {
                                 int assignResult = ptrsAssignable( pointerType->base, destAsPtr->base, env );
 …
                                 cost = Cost::zero;
                                 cost.incSafe( tableResult + 1 );
+                                cost.incSign( signMatrix[ BasicType::SignedInt ][ destAsBasic->get_kind() ] );
+                        } // if
+                        }
                 } else if ( dynamic_cast< PointerType* >( dest ) ) {
+                        cost = Cost::zero;
+                        cost.incSafe( maxIntCost + 2 ); // +1 for zero_t -> int, +1 for disambiguation
+                } // if
+                        cost = Cost::safe;
+                }
+        }
 …
                                 cost = Cost::zero;
                                 cost.incSafe( tableResult + 1 );
+                                cost.incSign( signMatrix[ BasicType::SignedInt ][ destAsBasic->get_kind() ] );
+                        } // if
+                } // if
+                        }
+                }
+        }
 } // namespace ResolvExpr

src/ResolvExpr/Cost.h

-              r933f32f
+              r6a9d4b4
 // Cost.h --
 //
 // Author           : Peter Buhr and Aaron Moss
+// Author           : Richard C. Bilson
 // Created On       : Sun May 17 09:39:50 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Mon Apr 29 18:33:44 2019
 // Update Count     : 49
+// Last Modified By : Aaron B. Moss
+// Last Modified On : Fri Oct 05 14:32:00 2018
+// Update Count     : 7
 //
 …
 #include <iostream>
-#include <cassert>
-#include <climits>
 namespace ResolvExpr {
-#if 0
-        //*************************** OLD ***************************
         class Cost {
           private:
+                Cost( int unsafeCost, int polyCost, int safeCost, int signCost,
+                          int varCost, int specCost, int referenceCost );
+                Cost( int unsafeCost, int polyCost, int safeCost, int varCost, int specCost,
+                        int referenceCost );
           public:
                 Cost & incUnsafe( int inc = 1 );
                 Cost & incPoly( int inc = 1 );
                 Cost & incSafe( int inc = 1 );
-                Cost & incSign( int inc = 1 );
                 Cost & incVar( int inc = 1 );
                 Cost & decSpec( int inc = 1 );
 …
                 int get_polyCost() const { return polyCost; }
                 int get_safeCost() const { return safeCost; }
-                int get_signCost() const { return signCost; }
                 int get_varCost() const { return varCost; }
                 int get_specCost() const { return specCost; }
 …
                 Cost operator+( const Cost &other ) const;
+                Cost operator-( const Cost &other ) const;
                 Cost &operator+=( const Cost &other );
                 bool operator<( const Cost &other ) const;
 …
                 static const Cost poly;
                 static const Cost safe;
-                static const Cost sign;
                 static const Cost var;
                 static const Cost spec;
 …
                 int polyCost;       ///< Count of parameters and return values bound to some poly type
                 int safeCost;       ///< Safe (widening) conversions
-                int signCost;       ///< Count of safe sign conversions
                 int varCost;        ///< Count of polymorphic type variables
                 int specCost;       ///< Polymorphic type specializations (type assertions), negative cost
 …
         };
         inline Cost::Cost( int unsafeCost, int polyCost, int safeCost, int signCost,
                                            int varCost, int specCost, int referenceCost )
                 : unsafeCost( unsafeCost ), polyCost( polyCost ), safeCost( safeCost ), signCost( signCost ),
                   varCost( varCost ), specCost( specCost ), referenceCost( referenceCost ) {}
+        inline Cost::Cost( int unsafeCost, int polyCost, int safeCost, int varCost, int specCost,
+                        int referenceCost )
+                : unsafeCost( unsafeCost ), polyCost( polyCost ), safeCost( safeCost ), varCost( varCost ),
+                  specCost( specCost ), referenceCost( referenceCost ) {}
         inline Cost & Cost::incUnsafe( int inc ) {
 …
                 if ( *this == infinity ) return *this;
                 safeCost += inc;
-                return *this;
+        }
-        inline Cost & Cost::incSign( int inc ) {
-                if ( *this == infinity ) return *this;
-                signCost += inc;
                 return *this;
+        }
 …
         inline Cost Cost::operator+( const Cost &other ) const {
                 if ( *this == infinity || other == infinity ) return infinity;
+                return Cost{
+                        unsafeCost + other.unsafeCost, polyCost + other.polyCost, safeCost + other.safeCost,
+                                signCost + other.signCost, varCost + other.varCost, specCost + other.specCost,
+                                referenceCost + other.referenceCost };
+                return Cost{
+                        unsafeCost + other.unsafeCost, polyCost + other.polyCost, safeCost + other.safeCost,
+                        varCost + other.varCost, specCost + other.specCost,
+                        referenceCost + other.referenceCost };
+        }
+        inline Cost Cost::operator-( const Cost &other ) const {
+                if ( *this == infinity || other == infinity ) return infinity;
+                return Cost{
+                        unsafeCost - other.unsafeCost, polyCost - other.polyCost, safeCost - other.safeCost,
+                        varCost - other.varCost, specCost - other.specCost,
+                        referenceCost - other.referenceCost };
+        }
 …
                 polyCost += other.polyCost;
                 safeCost += other.safeCost;
-                signCost += other.signCost;
                 varCost += other.varCost;
                 specCost += other.specCost;
 …
                 } else if ( safeCost < other.safeCost ) {
                         return true;
-                } else if ( signCost > other.signCost ) {
-                        return false;
-                } else if ( signCost < other.signCost ) {
-                        return true;
                 } else if ( varCost > other.varCost ) {
                         return false;
 …
                 c = polyCost - other.polyCost; if ( c ) return c;
                 c = safeCost - other.safeCost; if ( c ) return c;
-                c = signCost - other.signCost; if ( c ) return c;
                 c = varCost - other.varCost; if ( c ) return c;
                 c = specCost - other.specCost; if ( c ) return c;
 …
                         && polyCost == other.polyCost
                         && safeCost == other.safeCost
-                        && signCost == other.signCost
                         && varCost == other.varCost
                         && specCost == other.specCost
 …
         inline std::ostream &operator<<( std::ostream &os, const Cost &cost ) {
+                return os << "( " << cost.unsafeCost << ", " << cost.polyCost << ", "
+                          << cost.safeCost << ", " << cost.signCost << ", "
+                                  << cost.varCost << ", " << cost.specCost << ", "
+                return os << "( " << cost.unsafeCost << ", " << cost.polyCost << ", "
+                          << cost.safeCost << ", " << cost.varCost << ", " << cost.specCost << ", "
                           << cost.referenceCost << " )";
+        }
-#else
-        //*************************** NEW ***************************
-        // To maximize performance and space, the 7 resolution costs are packed into a single 64-bit word. However, the
-        // specialization cost is a negative value so a correction is needed is a few places.
-        class Cost {
-                union {
-                        struct {
-                        #if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
-                                // Little-endian => first value is low priority and last is high priority.
-                                unsigned char padding;                                  ///< unused
-                                unsigned char referenceCost;                    ///< reference conversions
-                                unsigned char specCost;                                 ///< Polymorphic type specializations (type assertions), negative cost
-                                unsigned char varCost;                                  ///< Count of polymorphic type variables
-                                unsigned char signCost;                                 ///< Count of safe sign conversions
-                                unsigned char safeCost;                                 ///< Safe (widening) conversions
-                                unsigned char polyCost;                                 ///< Count of parameters and return values bound to some poly type
-                                unsigned char unsafeCost;                               ///< Unsafe (narrowing) conversions
-                        #else
-                                #error Cost BIG_ENDIAN unsupported
-                        #endif
-                        } v;
-                        uint64_t all;
-                };
-                static const unsigned char correctb = 0xff;             // byte correction for negative spec cost
-                static const uint64_t correctw = 0x00'00'00'00'00'ff'00'00; //' word correction for negative spec cost
-          public:
-                // Compiler adjusts constants for correct endian.
-                enum : uint64_t {
-                        zero      = 0x00'00'00'00'00'ff'00'00,
-                        infinity  = 0xff'ff'ff'ff'ff'00'ff'ff,
-                        unsafe    = 0x01'00'00'00'00'ff'00'00,
-                        poly      = 0x00'01'00'00'00'ff'00'00,
-                        safe      = 0x00'00'01'00'00'ff'00'00,
-                        sign      = 0x00'00'00'01'00'ff'00'00,
-                        var       = 0x00'00'00'00'01'ff'00'00,
-                        spec      = 0x00'00'00'00'00'fe'00'00,
-                        reference = 0x00'00'00'00'00'ff'01'00,
-                }; //'
-                Cost( uint64_t all ) { Cost::all = all; }
-                Cost( int unsafeCost, int polyCost, int safeCost, int signCost, int varCost, int specCost, int referenceCost ) {
-                        // Assume little-endian => first value is low priority and last is high priority.
-                        v = {
-                        #if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
-                                (unsigned char)0,                                               // padding
-                                (unsigned char)referenceCost,                   // low priority
-                                (unsigned char)(specCost + correctb),   // correct for signedness
-                                (unsigned char)varCost,
-                                (unsigned char)signCost,
-                                (unsigned char)safeCost,
-                                (unsigned char)polyCost,
-                                (unsigned char)unsafeCost,                              // high priority
-                        #else
-                                #error Cost BIG_ENDIAN unsupported
-                        #endif
-                        };
+                }
-                int get_unsafeCost() const { return v.unsafeCost; }
-                int get_polyCost() const { return v.polyCost; }
-                int get_safeCost() const { return v.safeCost; }
-                int get_signCost() const { return v.signCost; }
-                int get_varCost() const { return v.varCost; }
-                int get_specCost() const { return -(correctb - v.specCost); }
-                int get_referenceCost() const { return v.referenceCost; }
-                friend bool operator==( const Cost, const Cost );
-                friend bool operator!=( const Cost lhs, const Cost rhs );
-                // returns negative for *this < rhs, 0 for *this == rhs, positive for *this > rhs
-                int compare( const Cost rhs ) const {
-                        if ( all == infinity ) return 1;
-                        if ( rhs.all == infinity ) return -1;
-                        return all > rhs.all ? 1 : all == rhs.all ? 0 : -1;
+                }
-                friend bool operator<( const Cost lhs, const Cost rhs );
-                friend Cost operator+( const Cost lhs, const Cost rhs );
-                Cost operator+=( const Cost rhs ) {
-                        if ( all == infinity ) return *this;
-                        if ( rhs.all == infinity ) {
-                                all = infinity;
-                                return *this;
+                        }
-                        all += rhs.all - correctw;                                      // correct for negative spec cost
-                        return *this;
+                }
-                Cost incUnsafe( int inc = 1 ) {
-                        if ( all != infinity ) { assert( v.unsafeCost + inc <= UCHAR_MAX ); v.unsafeCost += inc; }
-                        return *this;
+                }
-                Cost incPoly( int inc = 1 ) {
-                        if ( all != infinity ) { assert( v.polyCost + inc <= UCHAR_MAX ); v.polyCost += inc; }
-                        return *this;
+                }
-                Cost incSafe( int inc = 1 ) {
-                        if ( all != infinity ) { assert( v.safeCost + inc <= UCHAR_MAX ); v.safeCost += inc; }
-                        return *this;
+                }
-                Cost incSign( int inc = 1 ) {
-                        if ( all != infinity ) { assert( v.signCost + inc <= UCHAR_MAX ); v.signCost += inc; }
-                        return *this;
+                }
-                Cost incVar( int inc = 1 ) {
-                        if ( all != infinity ) { assert( v.varCost + inc <= UCHAR_MAX ); v.varCost += inc; }
-                        return *this;
+                }
-                Cost decSpec( int dec = 1 ) {
-                        if ( all != infinity ) { assert( v.specCost - dec >= 0 ); v.specCost -= dec; }
-                        return *this;
+                }
-                Cost incReference( int inc = 1 ) {
-                        if ( all != infinity ) { assert( v.referenceCost + inc <= UCHAR_MAX ); v.referenceCost += inc; }
-                        return *this;
+                }
-                friend std::ostream & operator<<( std::ostream & os, const Cost cost );
-        };
-        inline bool operator==( const Cost lhs, const Cost rhs ) {
-                return lhs.all == rhs.all;
+        }
-        inline bool operator!=( const Cost lhs, const Cost rhs ) {
-                return !( lhs.all == rhs.all );
+        }
-        inline bool operator<( const Cost lhs, const Cost rhs ) {
-                if ( lhs.all == Cost::infinity ) return false;
-                if ( rhs.all == Cost::infinity ) return true;
-                return lhs.all < rhs.all;
+        }
-        inline Cost operator+( const Cost lhs, const Cost rhs ) {
-                if ( lhs.all == Cost::infinity || rhs.all == Cost::infinity ) return Cost{ Cost::infinity };
-                return Cost{ lhs.all + rhs.all - Cost::correctw }; // correct for negative spec cost
+        }
-        inline std::ostream & operator<<( std::ostream & os, const Cost cost ) {
-                return os << "( " << cost.get_unsafeCost() << ", " << cost.get_polyCost() << ", " << cost.get_safeCost()
-                                  << ", " << cost.get_signCost() << ", " << cost.get_varCost() << ", " << cost.get_specCost()
-                                  << ", " << cost.get_referenceCost() << " )";
+        }
-#endif // 0
 } // namespace ResolvExpr

src/ResolvExpr/RenameVars.cc

-              r933f32f
+              r6a9d4b4
 // Created On       : Sun May 17 12:05:18 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Tue Apr 30 17:07:57 2019
 // Update Count     : 7
+// Last Modified On : Wed Mar  2 17:36:32 2016
+// Update Count     : 5
 //
 …
                   private:
                         int level, resetCount;
                         std::list< std::unordered_map< std::string, std::string > > mapStack;
+                        std::list< std::map< std::string, std::string > > mapStack;
                 };
 …
         namespace {
                 RenameVars::RenameVars() : level( 0 ), resetCount( 0 ) {
                         mapStack.push_front( std::unordered_map< std::string, std::string >() );
+                        mapStack.push_front( std::map< std::string, std::string >() );
+                }
 …
                 void RenameVars::previsit( TypeInstType * instType ) {
                         previsit( (Type *)instType );
                         std::unordered_map< std::string, std::string >::const_iterator i = mapStack.front().find( instType->name );
+                        std::map< std::string, std::string >::const_iterator i = mapStack.front().find( instType->name );
                         if ( i != mapStack.front().end() ) {
                                 instType->name = i->second;

src/ResolvExpr/ResolveAssertions.cc

-              r933f32f
+              r6a9d4b4
 #include <list>                     // for list
 #include <memory>                   // for unique_ptr
+#include <sstream>                  // for ostringstream
+#include <string>                   // for string
+#include <string>
 #include <unordered_map>            // for unordered_map, unordered_multimap
 #include <utility>                  // for move
 …
 #include "Alternative.h"            // for Alternative, AssertionItem, AssertionList
 #include "Common/FilterCombos.h"    // for filterCombos
-#include "Common/Indenter.h"        // for Indenter
 #include "Common/utility.h"         // for sort_mins
 #include "ResolvExpr/RenameVars.h"  // for renameTyVars
 …
 #include "SynTree/Expression.h"     // for InferredParams
 #include "TypeEnvironment.h"        // for TypeEnvironment, etc.
 #include "typeops.h"                // for adjustExprType, specCost
+#include "typeops.h"                // for adjustExprType
 #include "Unify.h"                  // for unify
 …
         using CandidateList = std::vector<AssnCandidate>;
+        /// Unique identifier for a yet-to-be-resolved assertion
+        struct AssnId {
+                DeclarationWithType* decl;  ///< Declaration of assertion
+                AssertionSetValue info;     ///< Information about assertion
+                AssnId(DeclarationWithType* decl, const AssertionSetValue& info) : decl(decl), info(info) {}
+        };
+        /// Cached assertion items
+        struct AssnCacheItem {
+                CandidateList matches;         ///< Possible matches for this assertion
+                std::vector<AssnId> deferIds;  ///< Deferred assertions which resolve to this item
+                AssnCacheItem( CandidateList&& m ) : matches(std::move(m)), deferIds() {}
+        };
+        /// Cache of resolved assertions
+        using AssnCache = std::unordered_map<std::string, AssnCacheItem>;
         /// Reference to single deferred item
         struct DeferRef {
+                const DeclarationWithType* decl;
+                const AssertionSetValue& info;
+                const AssnCacheItem& item;
                 const AssnCandidate& match;
         };
 …
         /// Acts like indexed list of DeferRef
         struct DeferItem {
+                const DeclarationWithType* decl;
+                const AssertionSetValue& info;
+                CandidateList matches;
+                DeferItem( DeclarationWithType* decl, const AssertionSetValue& info, CandidateList&& matches )
+                : decl(decl), info(info), matches(std::move(matches)) {}
+                bool empty() const { return matches.empty(); }
+                CandidateList::size_type size() const { return matches.size(); }
+                DeferRef operator[] ( unsigned i ) const { return { decl, info, matches[i] }; }
+                const AssnCache* cache;     ///< Cache storing assertion item
+                std::string key;            ///< Key into cache
+                DeferItem( const AssnCache& cache, const std::string& key ) : cache(&cache), key(key) {}
+                bool empty() const { return cache->at(key).matches.empty(); }
+                CandidateList::size_type size() const { return cache->at(key).matches.size(); }
+                DeferRef operator[] ( unsigned i ) const {
+                        const AssnCacheItem& item = cache->at(key);
+                        return { item, item.matches[i] };
+                }
+                // sortable by key
+                // TODO look into optimizing combination process with other sort orders (e.g. by number
+                // of matches in candidate)
+                bool operator< ( const DeferItem& o ) const { return key < o.key; }
+                bool operator== ( const DeferItem& o ) const { return key == o.key; }
         };
 …
                                 for ( const auto& assn : x.assns ) {
                                         k += computeConversionCost(
+                                                assn.match.adjType, assn.decl->get_type(), indexer, x.env );
+                                        // mark vars+specialization cost on function-type assertions
+                                        PointerType* ptr = dynamic_cast< PointerType* >( assn.decl->get_type() );
+                                        if ( ! ptr ) continue;
+                                        FunctionType* func = dynamic_cast< FunctionType* >( ptr->base );
+                                        if ( ! func ) continue;
+                                        for ( DeclarationWithType* formal : func->parameters ) {
+                                                k.decSpec( specCost( formal->get_type() ) );
+                                        }
+                                        k.incVar( func->forall.size() );
+                                        for ( TypeDecl* td : func->forall ) {
+                                                k.decSpec( td->assertions.size() );
+                                        }
+                                                assn.match.adjType, assn.item.deferIds[0].decl->get_type(), indexer,
+                                                x.env );
+                                }
                                 it = cache.emplace_hint( it, &x, k );
 …
         /// Resolve a single assertion, in context
         bool resolveAssertion( AssertionItem& assn, ResnState& resn ) {
+        bool resolveAssertion( AssertionItem& assn, ResnState& resn, AssnCache& cache ) {
                 // skip unused assertions
                 if ( ! assn.info.isUsed ) return true;
+                // lookup candidates for this assertion
+                std::list< SymTab::Indexer::IdData > candidates;
+                resn.indexer.lookupId( assn.decl->name, candidates );
+                // find the candidates that unify with the desired type
+                CandidateList matches;
+                for ( const auto& cdata : candidates ) {
+                        DeclarationWithType* candidate = cdata.id;
+                        // build independent unification context for candidate
+                        AssertionSet have, newNeed;
+                        TypeEnvironment newEnv{ resn.alt.env };
+                        OpenVarSet newOpenVars{ resn.alt.openVars };
+                        Type* adjType = candidate->get_type()->clone();
+                        adjustExprType( adjType, newEnv, resn.indexer );
+                        renameTyVars( adjType );
+                        // keep unifying candidates
+                        if ( unify( assn.decl->get_type(), adjType, newEnv, newNeed, have, newOpenVars,
+                                        resn.indexer ) ) {
+                                // set up binding slot for recursive assertions
+                                UniqueId crntResnSlot = 0;
+                                if ( ! newNeed.empty() ) {
+                                        crntResnSlot = ++globalResnSlot;
+                                        for ( auto& a : newNeed ) {
+                                                a.second.resnSlot = crntResnSlot;
+                // check cache for this assertion
+                std::string assnKey = SymTab::Mangler::mangleAssnKey( assn.decl, resn.alt.env );
+                auto it = cache.find( assnKey );
+                // attempt to resolve assertion if this is the first time seen
+                if ( it == cache.end() ) {
+                        // lookup candidates for this assertion
+                        std::list< SymTab::Indexer::IdData > candidates;
+                        resn.indexer.lookupId( assn.decl->name, candidates );
+                        // find the candidates that unify with the desired type
+                        CandidateList matches;
+                        for ( const auto& cdata : candidates ) {
+                                DeclarationWithType* candidate = cdata.id;
+                                // build independent unification context for candidate
+                                AssertionSet have, newNeed;
+                                TypeEnvironment newEnv{ resn.alt.env };
+                                OpenVarSet newOpenVars{ resn.alt.openVars };
+                                Type* adjType = candidate->get_type()->clone();
+                                adjustExprType( adjType, newEnv, resn.indexer );
+                                renameTyVars( adjType );
+                                // keep unifying candidates
+                                if ( unify( assn.decl->get_type(), adjType, newEnv, newNeed, have, newOpenVars,
+                                                resn.indexer ) ) {
+                                        // set up binding slot for recursive assertions
+                                        UniqueId crntResnSlot = 0;
+                                        if ( ! newNeed.empty() ) {
+                                                crntResnSlot = ++globalResnSlot;
+                                                for ( auto& a : newNeed ) {
+                                                        a.second.resnSlot = crntResnSlot;
+                                                }
+                                        }
+                                }
                                 matches.emplace_back( cdata, adjType, std::move(newEnv), std::move(have),
                                         std::move(newNeed), std::move(newOpenVars), crntResnSlot );
                         } else {
                                 delete adjType;
+                                        matches.emplace_back( cdata, adjType, std::move(newEnv), std::move(have),
+                                                std::move(newNeed), std::move(newOpenVars), crntResnSlot );
+                                } else {
+                                        delete adjType;
+                                }
+                        }
+                }
+                        it = cache.emplace_hint( it, assnKey, AssnCacheItem{ std::move(matches) } );
+                }
+                CandidateList& matches = it->second.matches;
                 // break if no suitable assertion
 …
                 // defer if too many suitable assertions
                 if ( matches.size() > 1 ) {
+                        resn.deferred.emplace_back( assn.decl, assn.info, std::move(matches) );
+                        it->second.deferIds.emplace_back( assn.decl, assn.info );
+                        resn.deferred.emplace_back( cache, assnKey );
                         return true;
+                }
 …
                 addToIndexer( match.have, resn.indexer );
                 resn.newNeed.insert( match.need.begin(), match.need.end() );
                 resn.alt.env = std::move(match.env);
                 resn.alt.openVars = std::move(match.openVars);
+                resn.alt.env = match.env;
+                resn.alt.openVars = match.openVars;
                 bindAssertion( assn.decl, assn.info, resn.alt, match, resn.inferred );
 …
         static const int recursionLimit = /* 10 */ 4;
         void resolveAssertions( Alternative& alt, const SymTab::Indexer& indexer, AltList& out, std::list<std::string>& errors ) {
+        void resolveAssertions( Alternative& alt, const SymTab::Indexer& indexer, AltList& out ) {
                 // finish early if no assertions to resolve
                 if ( alt.need.empty() ) {
 …
                 ResnList resns{ ResnState{ alt, root_indexer } };
                 ResnList new_resns{};
+                AssnCache assnCache;
                 // resolve assertions in breadth-first-order up to a limited number of levels deep
 …
                                 for ( auto& assn : resn.need ) {
                                         // fail early if any assertion is not resolvable
+                                        if ( ! resolveAssertion( assn, resn ) ) {
+                                                Indenter tabs{ Indenter::tabsize, 3 };
+                                                std::ostringstream ss;
+                                                ss << tabs << "Unsatisfiable alternative:\n";
+                                                resn.alt.print( ss, ++tabs );
+                                                ss << --tabs << "Could not satisfy assertion:\n";
+                                                assn.decl->print( ss, ++tabs );
+                                                errors.emplace_back( ss.str() );
+                                                goto nextResn;
+                                        }
+                                        if ( ! resolveAssertion( assn, resn, assnCache ) ) goto nextResn;
+                                }
 …
+                                        }
                                 } else {
+                                        // only resolve each deferred assertion once
+                                        std::sort( resn.deferred.begin(), resn.deferred.end() );
+                                        auto last = std::unique( resn.deferred.begin(), resn.deferred.end() );
+                                        resn.deferred.erase( last, resn.deferred.end() );
                                         // resolve deferred assertions by mutual compatibility
                                         std::vector<CandidateEnvMerger::OutType> compatible = filterCombos(
                                                 resn.deferred,
                                                 CandidateEnvMerger{ resn.alt.env, resn.alt.openVars, resn.indexer } );
-                                        // fail early if no mutually-compatible assertion satisfaction
-                                        if ( compatible.empty() ) {
-                                                Indenter tabs{ Indenter::tabsize, 3 };
-                                                std::ostringstream ss;
-                                                ss << tabs << "Unsatisfiable alternative:\n";
-                                                resn.alt.print( ss, ++tabs );
-                                                ss << --tabs << "No mutually-compatible satisfaction for assertions:\n";
-                                                ++tabs;
-                                                for ( const auto& d : resn.deferred ) {
-                                                        d.decl->print( ss, tabs );
+                                                }
-                                                errors.emplace_back( ss.str() );
-                                                goto nextResn;
+                                        }
                                         // sort by cost
                                         CandidateCost coster{ resn.indexer };
 …
                                                         new_resn.newNeed.insert( match.need.begin(), match.need.end() );
+                                                        bindAssertion( r.decl, r.info, new_resn.alt, match, new_resn.inferred );
+                                                        // for each deferred assertion with the same form
+                                                        for ( AssnId id : r.item.deferIds ) {
+                                                                bindAssertion(
+                                                                        id.decl, id.info, new_resn.alt, match, new_resn.inferred );
+                                                        }
+                                                }

src/ResolvExpr/ResolveAssertions.h

r933f32f	r6a9d4b4
24	24	namespace ResolvExpr {
25	25	/// Recursively resolves all assertions provided in an alternative; returns true iff succeeds
26		void resolveAssertions( Alternative& alt, const SymTab::Indexer& indexer, AltList& out~~, std::list<std::string>& errors~~ );
	26	void resolveAssertions( Alternative& alt, const SymTab::Indexer& indexer, AltList& out );
27	27	} // namespace ResolvExpr
28	28

src/ResolvExpr/Resolver.cc

-              r933f32f
+              r6a9d4b4
 // Author           : Richard C. Bilson
 // Created On       : Sun May 17 12:17:01 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Tue Feb 19 18:09:56 2019
 // Update Count     : 240
+// Last Modified By : Aaron B. Moss
+// Last Modified On : Fri Oct 05 09:43:00 2018
+// Update Count     : 214
 //
 …
+                }
                 void previsit( FunctionDecl * functionDecl );
                 void postvisit( FunctionDecl * functionDecl );
                 void previsit( ObjectDecl * objectDecll );
+                void previsit( FunctionDecl *functionDecl );
+                void postvisit( FunctionDecl *functionDecl );
+                void previsit( ObjectDecl *objectDecll );
                 void previsit( EnumDecl * enumDecl );
                 void previsit( StaticAssertDecl * assertDecl );
 …
                 void previsit( PointerType * at );
                 void previsit( ExprStmt * exprStmt );
                 void previsit( AsmExpr * asmExpr );
                 void previsit( AsmStmt * asmStmt );
                 void previsit( IfStmt * ifStmt );
                 void previsit( WhileStmt * whileStmt );
                 void previsit( ForStmt * forStmt );
                 void previsit( SwitchStmt * switchStmt );
                 void previsit( CaseStmt * caseStmt );
                 void previsit( BranchStmt * branchStmt );
                 void previsit( ReturnStmt * returnStmt );
                 void previsit( ThrowStmt * throwStmt );
                 void previsit( CatchStmt * catchStmt );
+                void previsit( ExprStmt *exprStmt );
+                void previsit( AsmExpr *asmExpr );
+                void previsit( AsmStmt *asmStmt );
+                void previsit( IfStmt *ifStmt );
+                void previsit( WhileStmt *whileStmt );
+                void previsit( ForStmt *forStmt );
+                void previsit( SwitchStmt *switchStmt );
+                void previsit( CaseStmt *caseStmt );
+                void previsit( BranchStmt *branchStmt );
+                void previsit( ReturnStmt *returnStmt );
+                void previsit( ThrowStmt *throwStmt );
+                void previsit( CatchStmt *catchStmt );
                 void previsit( WaitForStmt * stmt );
                 void previsit( SingleInit * singleInit );
                 void previsit( ListInit * listInit );
                 void previsit( ConstructorInit * ctorInit );
+                void previsit( SingleInit *singleInit );
+                void previsit( ListInit *listInit );
+                void previsit( ConstructorInit *ctorInit );
           private:
                 typedef std::list< Initializer * >::iterator InitIterator;
 …
+        }
         void resolveDecl( Declaration * decl, const SymTab::Indexer & indexer ) {
+        void resolveDecl( Declaration * decl, const SymTab::Indexer &indexer ) {
                 PassVisitor<Resolver> resolver( indexer );
                 maybeAccept( decl, resolver );
 …
                 };
                 void finishExpr( Expression *& expr, const TypeEnvironment & env, TypeSubstitution * oldenv = nullptr ) {
+                void finishExpr( Expression *&expr, const TypeEnvironment &env, TypeSubstitution * oldenv = nullptr ) {
                         expr->env = oldenv ? oldenv->clone() : new TypeSubstitution;
                         env.makeSubstitution( *expr->env );
 …
         // used in resolveTypeof
         Expression * resolveInVoidContext( Expression * expr, const SymTab::Indexer & indexer ) {
+        Expression * resolveInVoidContext( Expression *expr, const SymTab::Indexer &indexer ) {
                 TypeEnvironment env;
                 return resolveInVoidContext( expr, indexer, env );
+        }
         Expression * resolveInVoidContext( Expression * expr, const SymTab::Indexer & indexer, TypeEnvironment & env ) {
+        Expression * resolveInVoidContext( Expression *expr, const SymTab::Indexer &indexer, TypeEnvironment &env ) {
                 // it's a property of the language that a cast expression has either 1 or 0 interpretations; if it has 0
                 // interpretations, an exception has already been thrown.
                 assertf( expr, "expected a non-null expression." );
                 CastExpr * untyped = new CastExpr( expr ); // cast to void
                 untyped->location = expr->location;
+                static CastExpr untyped( nullptr ); // cast to void
+                untyped.location = expr->location;
                 // set up and resolve expression cast to void
+                untyped.arg = expr;
                 Alternative choice;
                 findUnfinishedKindExpression( untyped, choice, indexer, "", standardAlternativeFilter, ResolvMode::withAdjustment() );
+                findUnfinishedKindExpression( &untyped, choice, indexer, "", standardAlternativeFilter, ResolvMode::withAdjustment() );
                 CastExpr * castExpr = strict_dynamic_cast< CastExpr * >( choice.expr );
-                assert( castExpr );
                 env = std::move( choice.env );
 …
                 // unlink the arg so that it isn't deleted twice at the end of the program
                 untyped->arg = nullptr;
+                untyped.arg = nullptr;
                 return ret;
+        }
         void findVoidExpression( Expression *& untyped, const SymTab::Indexer & indexer ) {
+        void findVoidExpression( Expression *& untyped, const SymTab::Indexer &indexer ) {
                 resetTyVarRenaming();
                 TypeEnvironment env;
 …
+        }
         void findSingleExpression( Expression *& untyped, const SymTab::Indexer & indexer ) {
+        void findSingleExpression( Expression *&untyped, const SymTab::Indexer &indexer ) {
                 findKindExpression( untyped, indexer, "", standardAlternativeFilter );
+        }
 …
                         if ( dynamic_cast< EnumInstType * >( type ) ) {
                                 return true;
                         } else if ( BasicType * bt = dynamic_cast< BasicType * >( type ) ) {
+                        } else if ( BasicType *bt = dynamic_cast< BasicType * >( type ) ) {
                                 return bt->isInteger();
                         } else if ( dynamic_cast< ZeroType* >( type ) != nullptr || dynamic_cast< OneType* >( type ) != nullptr ) {
 …
+                }
                 void findIntegralExpression( Expression *& untyped, const SymTab::Indexer & indexer ) {
+                void findIntegralExpression( Expression *& untyped, const SymTab::Indexer &indexer ) {
                         findKindExpression( untyped, indexer, "condition", isIntegralType );
+                }
 …
+        }
         void Resolver::previsit( ObjectDecl * objectDecl ) {
+        void Resolver::previsit( ObjectDecl *objectDecl ) {
                 // To handle initialization of routine pointers, e.g., int (*fp)(int) = foo(), means that
                 // class-variable initContext is changed multiple time because the LHS is analysed twice.
 …
+        }
         void Resolver::previsit( FunctionDecl * functionDecl ) {
+        void Resolver::previsit( FunctionDecl *functionDecl ) {
 #if 0
                 std::cerr << "resolver visiting functiondecl ";
 …
+        }
         void Resolver::postvisit( FunctionDecl * functionDecl ) {
+        void Resolver::postvisit( FunctionDecl *functionDecl ) {
                 // default value expressions have an environment which shouldn't be there and trips up
                 // later passes.
 …
+        }
         void Resolver::previsit( ExprStmt * exprStmt ) {
+        void Resolver::previsit( ExprStmt *exprStmt ) {
                 visit_children = false;
                 assertf( exprStmt->expr, "ExprStmt has null Expression in resolver" );
 …
+        }
         void Resolver::previsit( AsmExpr * asmExpr ) {
+        void Resolver::previsit( AsmExpr *asmExpr ) {
                 visit_children = false;
                 findVoidExpression( asmExpr->operand, indexer );
 …
+        }
         void Resolver::previsit( AsmStmt * asmStmt ) {
+        void Resolver::previsit( AsmStmt *asmStmt ) {
                 visit_children = false;
                 acceptAll( asmStmt->get_input(), *visitor );
 …
+        }
         void Resolver::previsit( IfStmt * ifStmt ) {
+        void Resolver::previsit( IfStmt *ifStmt ) {
                 findIntegralExpression( ifStmt->condition, indexer );
+        }
         void Resolver::previsit( WhileStmt * whileStmt ) {
+        void Resolver::previsit( WhileStmt *whileStmt ) {
                 findIntegralExpression( whileStmt->condition, indexer );
+        }
         void Resolver::previsit( ForStmt * forStmt ) {
+        void Resolver::previsit( ForStmt *forStmt ) {
                 if ( forStmt->condition ) {
                         findIntegralExpression( forStmt->condition, indexer );
 …
+        }
         void Resolver::previsit( SwitchStmt * switchStmt ) {
+        void Resolver::previsit( SwitchStmt *switchStmt ) {
                 GuardValue( currentObject );
                 findIntegralExpression( switchStmt->condition, indexer );
 …
+        }
         void Resolver::previsit( CaseStmt * caseStmt ) {
+        void Resolver::previsit( CaseStmt *caseStmt ) {
                 if ( caseStmt->condition ) {
                         std::list< InitAlternative > initAlts = currentObject.getOptions();
 …
+        }
         void Resolver::previsit( BranchStmt * branchStmt ) {
+        void Resolver::previsit( BranchStmt *branchStmt ) {
                 visit_children = false;
                 // must resolve the argument for a computed goto
 …
+        }
         void Resolver::previsit( ReturnStmt * returnStmt ) {
+        void Resolver::previsit( ReturnStmt *returnStmt ) {
                 visit_children = false;
                 if ( returnStmt->expr ) {
 …
+        }
         void Resolver::previsit( ThrowStmt * throwStmt ) {
+        void Resolver::previsit( ThrowStmt *throwStmt ) {
                 visit_children = false;
                 // TODO: Replace *exception type with &exception type.
 …
+        }
         void Resolver::previsit( CatchStmt * catchStmt ) {
+        void Resolver::previsit( CatchStmt *catchStmt ) {
                 if ( catchStmt->cond ) {
                         findSingleExpression( catchStmt->cond, new BasicType( noQualifiers, BasicType::Bool ), indexer );
 …
+                                                }
                                                 catch( SemanticErrorException & e ) {
+                                                catch( SemanticErrorException &e ) {
                                                         errors.append( e );
+                                                }
+                                        }
+                                }
                                 catch( SemanticErrorException & e ) {
+                                catch( SemanticErrorException &e ) {
                                         errors.append( e );
+                                }
 …
+        }
         void Resolver::previsit( SingleInit * singleInit ) {
+        void Resolver::previsit( SingleInit *singleInit ) {
                 visit_children = false;
                 // resolve initialization using the possibilities as determined by the currentObject cursor
 …
                                 if ( PointerType * pt = dynamic_cast< PointerType *>( newExpr->get_result() ) ) {
                                         if ( isCharType( pt->get_base() ) ) {
                                                 if ( CastExpr * ce = dynamic_cast< CastExpr * >( newExpr ) ) {
+                                                if ( CastExpr *ce = dynamic_cast< CastExpr * >( newExpr ) ) {
                                                         // strip cast if we're initializing a char[] with a char *,
                                                         // e.g.  char x[] = "hello";
 …
+        }
         void Resolver::previsit( ConstructorInit * ctorInit ) {
+        void Resolver::previsit( ConstructorInit *ctorInit ) {
                 visit_children = false;
                 // xxx - fallback init has been removed => remove fallbackInit function and remove complexity from FixInit and remove C-init from ConstructorInit

src/ResolvExpr/Resolver.h

-              r933f32f
+              r6a9d4b4
 // Created On       : Sun May 17 12:18:34 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Mon Feb 18 20:40:38 2019
 // Update Count     : 4
+// Last Modified On : Sat Jul 22 09:36:57 2017
+// Update Count     : 3
 //
 …
         /// Checks types and binds syntactic constructs to typed representations
         void resolve( std::list< Declaration * > translationUnit );
         void resolveDecl( Declaration *, const SymTab::Indexer & indexer );
         Expression *resolveInVoidContext( Expression * expr, const SymTab::Indexer & indexer );
         void findVoidExpression( Expression *& untyped, const SymTab::Indexer & indexer );
         void findSingleExpression( Expression *& untyped, const SymTab::Indexer & indexer );
         void findSingleExpression( Expression *& untyped, Type * type, const SymTab::Indexer & indexer );
+        void resolveDecl( Declaration *, const SymTab::Indexer &indexer );
+        Expression *resolveInVoidContext( Expression * expr, const SymTab::Indexer &indexer );
+        void findVoidExpression( Expression *& untyped, const SymTab::Indexer &indexer );
+        void findSingleExpression( Expression *& untyped, const SymTab::Indexer &indexer );
+        void findSingleExpression( Expression *& untyped, Type * type, const SymTab::Indexer &indexer );
         void resolveCtorInit( ConstructorInit * ctorInit, const SymTab::Indexer & indexer );
         void resolveStmtExpr( StmtExpr * stmtExpr, const SymTab::Indexer & indexer );

src/ResolvExpr/TypeEnvironment.cc

-              r933f32f
+              r6a9d4b4
+        }
+        bool TypeEnvironment::bindVarToVar( TypeInstType *var1, TypeInstType *var2,
+                        TypeDecl::Data && data, AssertionSet &need, AssertionSet &have,
+                        const OpenVarSet &openVars, WidenMode widenMode, const SymTab::Indexer &indexer ) {
+        bool TypeEnvironment::bindVarToVar( TypeInstType *var1, TypeInstType *var2, const TypeDecl::Data & data, AssertionSet &need, AssertionSet &have, const OpenVarSet &openVars, WidenMode widenMode, const SymTab::Indexer &indexer ) {
                 auto class1 = internal_lookup( var1->get_name() );
 …
                                         class1->set_type( common );
+                                }
-                                class1->data.isComplete |= data.isComplete;
                                 env.erase( class2 );
                         } else return false;
 …
                                 class1->vars.insert( class2->vars.begin(), class2->vars.end() );
                                 class1->allowWidening = widen1;
-                                class1->data.isComplete |= data.isComplete;
                                 env.erase( class2 );
                         } else {
                                 class2->vars.insert( class1->vars.begin(), class1->vars.end() );
                                 class2->allowWidening = widen2;
-                                class2->data.isComplete |= data.isComplete;
                                 env.erase( class1 );
                         } // if
 …
                         class1->vars.insert( var2->get_name() );
                         class1->allowWidening = widen1;
-                        class1->data.isComplete |= data.isComplete;
                 } else if ( class2 != env.end() ) {
                         // var1 unbound, add to class2
                         class2->vars.insert( var1->get_name() );
                         class2->allowWidening = widen2;
-                        class2->data.isComplete |= data.isComplete;
                 } else {
                         // neither var bound, create new class

src/ResolvExpr/TypeEnvironment.h

-              r933f32f
+              r6a9d4b4
 // Author           : Richard C. Bilson
 // Created On       : Sun May 17 12:24:58 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Tue Apr 30 23:04:10 2019
 // Update Count     : 9
+// Last Modified By : Aaron B. Moss
+// Last Modified On : Mon Jun 18 11:58:00 2018
+// Update Count     : 4
 //
 …
 #include <iostream>                    // for ostream
 #include <list>                        // for list, list<>::iterator, list<>...
+#include <map>                                             // for map, map<>::value_compare
+#include <unordered_map>
+#include <set>                                             // for set
+#include <map>                         // for map, map<>::value_compare
+#include <set>                         // for set
 #include <string>                      // for string
 #include <utility>                     // for move, swap
 …
                 AssertionSetValue() : isUsed(false), resnSlot(0) {}
         };
         typedef std::map< DeclarationWithType *, AssertionSetValue, AssertCompare > AssertionSet;
         typedef std::unordered_map< std::string, TypeDecl::Data > OpenVarSet;
+        typedef std::map< DeclarationWithType*, AssertionSetValue, AssertCompare > AssertionSet;
+        typedef std::map< std::string, TypeDecl::Data > OpenVarSet;
         /// merges one set of open vars into another
 …
                 /// Binds the type classes represented by `var1` and `var2` together; will add
                 /// one or both classes if needed. Returns false on failure.
                 bool bindVarToVar( TypeInstType *var1, TypeInstType *var2, TypeDecl::Data && data, AssertionSet &need, AssertionSet &have, const OpenVarSet &openVars, WidenMode widenMode, const SymTab::Indexer &indexer );
+                bool bindVarToVar( TypeInstType *var1, TypeInstType *var2, const TypeDecl::Data & data, AssertionSet &need, AssertionSet &have, const OpenVarSet &openVars, WidenMode widenMode, const SymTab::Indexer &indexer );
                 /// Disallows widening for all bindings in the environment

src/ResolvExpr/Unify.cc

-              r933f32f
+              r6a9d4b4
 #include <string>                 // for string, operator==, operator!=, bas...
 #include <utility>                // for pair, move
+#include <vector>
+#include "AST/Node.hpp"
+#include "AST/Type.hpp"
 #include "Common/PassVisitor.h"   // for PassVisitor
 #include "FindOpenVars.h"         // for findOpenVars
 …
                 bool isopen2 = var2 && ( entry2 != openVars.end() );
+                if ( isopen1 && isopen2 ) {
+                        if ( entry1->second.kind != entry2->second.kind ) {
+                                result = false;
+                        } else {
+                                result = env.bindVarToVar(
+                                        var1, var2, TypeDecl::Data{ entry1->second, entry2->second }, needAssertions,
+                                        haveAssertions, openVars, widenMode, indexer );
+                        }
+                if ( isopen1 && isopen2 && entry1->second == entry2->second ) {
+                        result = env.bindVarToVar( var1, var2, entry1->second, needAssertions, haveAssertions, openVars, widenMode, indexer );
                 } else if ( isopen1 ) {
                         result = env.bindVar( var1, type2, entry1->second, needAssertions, haveAssertions, openVars, widenMode, indexer );
 …
+        }
+        // xxx - compute once and store in the FunctionType?
         Type * extractResultType( FunctionType * function ) {
                 if ( function->get_returnVals().size() == 0 ) {
 …
+                }
+        }
-        ast::ptr<ast::Type> extractResultType( const ast::FunctionType * func ) {
-                assert(!"restore after AST added to build");
-                // if ( func->returns.empty() ) return new ast::VoidType{};
-                // if ( func->returns.size() == 1 ) return func->returns[0]->get_type();
-                // std::vector<ast::ptr<ast::Type>> tys;
-                // for ( const ast::DeclWithType * decl : func->returns ) {
-                //      tys.emplace_back( decl->get_type() );
-                // }
-                // return new ast::TupleType{ std::move(tys) };
+        }
 } // namespace ResolvExpr

src/ResolvExpr/module.mk

-              r933f32f
+              r6a9d4b4
 ###############################################################################
+SRC_RESOLVEXPR = \
+      ResolvExpr/AdjustExprType.cc \
+      ResolvExpr/Alternative.cc \
+      ResolvExpr/AlternativeFinder.cc \
+      ResolvExpr/CastCost.cc \
+      ResolvExpr/CommonType.cc \
+      ResolvExpr/ConversionCost.cc \
+      ResolvExpr/CurrentObject.cc \
+      ResolvExpr/ExplodedActual.cc \
+      ResolvExpr/FindOpenVars.cc \
+      ResolvExpr/Occurs.cc \
+      ResolvExpr/PolyCost.cc \
+      ResolvExpr/PtrsAssignable.cc \
+      ResolvExpr/PtrsCastable.cc \
+      ResolvExpr/RenameVars.cc \
+      ResolvExpr/ResolveAssertions.cc \
+      ResolvExpr/Resolver.cc \
+      ResolvExpr/ResolveTypeof.cc \
+      ResolvExpr/SpecCost.cc \
+      ResolvExpr/TypeEnvironment.cc \
+      ResolvExpr/Unify.cc
+SRC += $(SRC_RESOLVEXPR) ResolvExpr/AlternativePrinter.cc
+SRCDEMANGLE += $(SRC_RESOLVEXPR)
+SRC += ResolvExpr/AlternativeFinder.cc \
+       ResolvExpr/Alternative.cc \
+       ResolvExpr/Unify.cc \
+       ResolvExpr/PtrsAssignable.cc \
+       ResolvExpr/CommonType.cc \
+       ResolvExpr/ConversionCost.cc \
+       ResolvExpr/CastCost.cc \
+       ResolvExpr/PtrsCastable.cc \
+       ResolvExpr/AdjustExprType.cc \
+       ResolvExpr/AlternativePrinter.cc \
+       ResolvExpr/Resolver.cc \
+       ResolvExpr/ResolveTypeof.cc \
+       ResolvExpr/RenameVars.cc \
+       ResolvExpr/FindOpenVars.cc \
+       ResolvExpr/PolyCost.cc \
+       ResolvExpr/Occurs.cc \
+       ResolvExpr/TypeEnvironment.cc \
+       ResolvExpr/CurrentObject.cc \
+       ResolvExpr/ExplodedActual.cc \
+       ResolvExpr/SpecCost.cc \
+       ResolvExpr/ResolveAssertions.cc

src/ResolvExpr/typeops.h

-              r933f32f
+              r6a9d4b4
 // Created On       : Sun May 17 07:28:22 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Feb  8 09:30:34 2019
 // Update Count     : 4
+// Last Modified On : Sat Jul 22 09:36:18 2017
+// Update Count     : 3
 //
 …
 #include <vector>
-#include "AST/Node.hpp"
-#include "AST/Type.hpp"
 #include "SynTree/SynTree.h"
 #include "SynTree/Type.h"
 …
         /// creates the type represented by the list of returnVals in a FunctionType. The caller owns the return value.
         Type * extractResultType( FunctionType * functionType );
-        /// Creates or extracts the type represented by the list of returns in a `FunctionType`.
-        ast::ptr<ast::Type> extractResultType( const ast::FunctionType * func );
         // in CommonType.cc
         Type * commonType( Type *type1, Type *type2, bool widenFirst, bool widenSecond, const SymTab::Indexer &indexer, TypeEnvironment &env, const OpenVarSet &openVars );
+        Type *commonType( Type *type1, Type *type2, bool widenFirst, bool widenSecond, const SymTab::Indexer &indexer, TypeEnvironment &env, const OpenVarSet &openVars );
         // in PolyCost.cc

src/SymTab/Indexer.cc

-              r933f32f
+              r6a9d4b4
 // Author           : Richard C. Bilson
 // Created On       : Sun May 17 21:37:33 2015
 // Last Modified By : Aaron B. Moss
 // Last Modified On : Fri Mar  8 13:55:00 2019
 // Update Count     : 21
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Thu Aug 17 16:08:40 2017
+// Update Count     : 20
 //
 …
 #include <cassert>                 // for assert, strict_dynamic_cast
+#include <iostream>                // for operator<<, basic_ostream, ostream
 #include <string>                  // for string, operator<<, operator!=
-#include <memory>                  // for shared_ptr, make_shared
 #include <unordered_map>           // for operator!=, unordered_map<>::const...
 #include <unordered_set>           // for unordered_set
 #include <utility>                 // for pair, make_pair, move
-#include <vector>                  // for vector
 #include "CodeGen/OperatorTable.h" // for isCtorDtor, isCtorDtorAssign
 #include "Common/SemanticError.h"  // for SemanticError
 #include "Common/utility.h"        // for cloneAll
+#include "Common/Stats/Counter.h"  // for counters
+#include "GenPoly/GenPoly.h"       // for getFunctionType
+#include "GenPoly/GenPoly.h"
 #include "InitTweak/InitTweak.h"   // for isConstructor, isCopyFunction, isC...
 #include "Mangler.h"               // for Mangler
 …
 #include "SynTree/Type.h"          // for Type, StructInstType, UnionInstType
+#define debugPrint(x) if ( doDebug ) { std::cerr << x; }
 namespace SymTab {
+        // Statistics block
+        namespace {
+                static inline auto stats() {
+                        using namespace Stats::Counters;
+                        static auto group   = build<CounterGroup>("Indexers");
+                        static struct {
+                                SimpleCounter * count;
+                                AverageCounter<double> * size;
+                                SimpleCounter * new_scopes;
+                                SimpleCounter * lazy_scopes;
+                                AverageCounter<double> * avg_scope_depth;
+                                MaxCounter<size_t> * max_scope_depth;
+                                SimpleCounter * add_calls;
+                                SimpleCounter * lookup_calls;
+                                SimpleCounter * map_lookups;
+                                SimpleCounter * map_mutations;
+                        } ret = {
+                                .count   = build<SimpleCounter>("Count", group),
+                                .size    = build<AverageCounter<double>>("Average Size", group),
+                                .new_scopes = build<SimpleCounter>("Scopes", group),
+                                .lazy_scopes = build<SimpleCounter>("Lazy Scopes", group),
+                                .avg_scope_depth = build<AverageCounter<double>>("Average Scope", group),
+                                .max_scope_depth = build<MaxCounter<size_t>>("Max Scope", group),
+                                .add_calls = build<SimpleCounter>("Add Calls", group),
+                                .lookup_calls = build<SimpleCounter>("Lookup Calls", group),
+                                .map_lookups = build<SimpleCounter>("Map Lookups", group),
+                                .map_mutations = build<SimpleCounter>("Map Mutations", group)
+        std::ostream & operator<<( std::ostream & out, const Indexer::IdData & data ) {
+                return out << "(" << data.id << "," << data.baseExpr << ")";
+        }
+        typedef std::unordered_map< std::string, Indexer::IdData > MangleTable;
+        typedef std::unordered_map< std::string, MangleTable > IdTable;
+        typedef std::unordered_map< std::string, NamedTypeDecl* > TypeTable;
+        typedef std::unordered_map< std::string, StructDecl* > StructTable;
+        typedef std::unordered_map< std::string, EnumDecl* > EnumTable;
+        typedef std::unordered_map< std::string, UnionDecl* > UnionTable;
+        typedef std::unordered_map< std::string, TraitDecl* > TraitTable;
+        void dump( const IdTable &table, std::ostream &os ) {
+                for ( IdTable::const_iterator id = table.begin(); id != table.end(); ++id ) {
+                        for ( MangleTable::const_iterator mangle = id->second.begin(); mangle != id->second.end(); ++mangle ) {
+                                os << mangle->second << std::endl;
+                        }
+                }
+        }
+        template< typename Decl >
+        void dump( const std::unordered_map< std::string, Decl* > &table, std::ostream &os ) {
+                for ( typename std::unordered_map< std::string, Decl* >::const_iterator it = table.begin(); it != table.end(); ++it ) {
+                        os << it->second << std::endl;
+                } // for
+        }
+        struct Indexer::Impl {
+                Impl( unsigned long _scope ) : refCount(1), scope( _scope ), size( 0 ), base(),
+                                idTable(), typeTable(), structTable(), enumTable(), unionTable(), traitTable() {}
+                Impl( unsigned long _scope, Indexer &&_base ) : refCount(1), scope( _scope ), size( 0 ), base( _base ),
+                                idTable(), typeTable(), structTable(), enumTable(), unionTable(), traitTable() {}
+                unsigned long refCount;   ///< Number of references to these tables
+                unsigned long scope;      ///< Scope these tables are associated with
+                unsigned long size;       ///< Number of elements stored in this table
+                const Indexer base;       ///< Base indexer this extends
+                IdTable idTable;          ///< Identifier namespace
+                TypeTable typeTable;      ///< Type namespace
+                StructTable structTable;  ///< Struct namespace
+                EnumTable enumTable;      ///< Enum namespace
+                UnionTable unionTable;    ///< Union namespace
+                TraitTable traitTable;    ///< Trait namespace
+        };
+        Indexer::Impl *Indexer::newRef( Indexer::Impl *toClone ) {
+                if ( ! toClone ) return 0;
+                // shorten the search chain by skipping empty links
+                Indexer::Impl *ret = toClone->size == 0 ? toClone->base.tables : toClone;
+                if ( ret ) { ++ret->refCount; }
+                return ret;
+        }
+        void Indexer::deleteRef( Indexer::Impl *toFree ) {
+                if ( ! toFree ) return;
+                if ( --toFree->refCount == 0 ) delete toFree;
+        }
+        void Indexer::removeSpecialOverrides( const std::string &id, std::list< IdData > & out ) const {
+                // only need to perform this step for constructors, destructors, and assignment functions
+                if ( ! CodeGen::isCtorDtorAssign( id ) ) return;
+                // helpful data structure to organize properties for a type
+                struct ValueType {
+                        struct DeclBall { // properties for this particular decl
+                                IdData decl;
+                                bool isUserDefinedFunc;
+                                bool isCopyFunc;
                         };
+                        return ret;
+                }
+        }
+        Indexer::Indexer()
+        : idTable(), typeTable(), structTable(), enumTable(), unionTable(), traitTable(),
+          prevScope(), scope( 0 ), repScope( 0 ) { ++*stats().count; }
+                        // properties for this type
+                        bool existsUserDefinedCopyFunc = false;    // user-defined copy ctor found
+                        BaseSyntaxNode * deleteStmt = nullptr;     // non-null if a user-defined function is found
+                        std::list< DeclBall > decls;
+                        // another FunctionDecl for the current type was found - determine
+                        // if it has special properties and update data structure accordingly
+                        ValueType & operator+=( IdData data ) {
+                                DeclarationWithType * function = data.id;
+                                bool isUserDefinedFunc = ! LinkageSpec::isOverridable( function->linkage );
+                                bool isCopyFunc = InitTweak::isCopyFunction( function, function->name );
+                                decls.push_back( DeclBall{ data, isUserDefinedFunc, isCopyFunc } );
+                                existsUserDefinedCopyFunc = existsUserDefinedCopyFunc || (isUserDefinedFunc && isCopyFunc);
+                                if ( isUserDefinedFunc && ! deleteStmt ) {
+                                        // any user-defined function can act as an implicit delete statement for generated constructors.
+                                        // a delete stmt should not act as an implicit delete statement.
+                                        deleteStmt = data.id;
+                                }
+                                return *this;
+                        }
+                }; // ValueType
+                std::list< IdData > copy;
+                copy.splice( copy.end(), out );
+                // organize discovered declarations by type
+                std::unordered_map< std::string, ValueType > funcMap;
+                for ( auto decl : copy ) {
+                        if ( FunctionDecl * function = dynamic_cast< FunctionDecl * >( decl.id ) ) {
+                                std::list< DeclarationWithType * > & params = function->type->parameters;
+                                assert( ! params.empty() );
+                                // use base type of pointer, so that qualifiers on the pointer type aren't considered.
+                                Type * base = InitTweak::getPointerBase( params.front()->get_type() );
+                                assert( base );
+                                funcMap[ Mangler::mangle( base ) ] += decl;
+                        } else {
+                                out.push_back( decl );
+                        }
+                }
+                // if a type contains user defined ctor/dtor/assign, then special rules trigger, which determine
+                // the set of ctor/dtor/assign that can be used  by the requester. In particular, if the user defines
+                // a default ctor, then the generated default ctor is unavailable, likewise for copy ctor
+                // and dtor. If the user defines any ctor/dtor, then no generated field ctors are available.
+                // If the user defines any ctor then the generated default ctor is unavailable (intrinsic default
+                // ctor must be overridden exactly). If the user defines anything that looks like a copy constructor,
+                // then the generated copy constructor is unavailable, and likewise for the assignment operator.
+                for ( std::pair< const std::string, ValueType > & pair : funcMap ) {
+                        ValueType & val = pair.second;
+                        for ( ValueType::DeclBall ball : val.decls ) {
+                                bool isNotUserDefinedFunc = ! ball.isUserDefinedFunc && ball.decl.id->linkage != LinkageSpec::Intrinsic;
+                                bool isCopyFunc = ball.isCopyFunc;
+                                bool existsUserDefinedCopyFunc = val.existsUserDefinedCopyFunc;
+                                // only implicitly delete non-user defined functions that are not intrinsic, and are
+                                // not copy functions (assignment or copy constructor). If a  user-defined copy function exists,
+                                // do not pass along the non-user-defined copy functions since signatures do not have to match,
+                                // and the generated functions will often be cheaper.
+                                if ( isNotUserDefinedFunc ) {
+                                        if ( isCopyFunc ) {
+                                                // Skip over non-user-defined copy functions when there is a user-defined copy function.
+                                                // Since their signatures do not have to be exact, deleting them is the wrong choice.
+                                                if ( existsUserDefinedCopyFunc ) continue;
+                                        } else {
+                                                // delete non-user-defined non-copy functions if applicable.
+                                                // deleteStmt will be non-null only if a user-defined function is found.
+                                                ball.decl.deleteStmt = val.deleteStmt;
+                                        }
+                                }
+                                out.push_back( ball.decl );
+                        }
+                }
+        }
+        void Indexer::makeWritable() {
+                if ( ! tables ) {
+                        // create indexer if not yet set
+                        tables = new Indexer::Impl( scope );
+                } else if ( tables->refCount > 1 || tables->scope != scope ) {
+                        // make this indexer the base of a fresh indexer at the current scope
+                        tables = new Indexer::Impl( scope, std::move( *this ) );
+                }
+        }
+        Indexer::Indexer() : tables( 0 ), scope( 0 ) {}
+        Indexer::Indexer( const Indexer &that ) : doDebug( that.doDebug ), tables( newRef( that.tables ) ), scope( that.scope ) {}
+        Indexer::Indexer( Indexer &&that ) : doDebug( that.doDebug ), tables( that.tables ), scope( that.scope ) {
+                that.tables = 0;
+        }
         Indexer::~Indexer() {
+                stats().size->push( idTable ? idTable->size() : 0 );
+        }
+        void Indexer::lazyInitScope() {
+                if ( repScope < scope ) {
+                        ++*stats().lazy_scopes;
+                        // create rollback
+                        prevScope = std::make_shared<Indexer>( *this );
+                        // update repScope
+                        repScope = scope;
+                }
+        }
+        void Indexer::enterScope() {
+                ++scope;
+                ++*stats().new_scopes;
+                stats().avg_scope_depth->push( scope );
+                stats().max_scope_depth->push( scope );
+        }
+        void Indexer::leaveScope() {
+                if ( repScope == scope ) {
+                        Ptr prev = prevScope;           // make sure prevScope stays live
+                        *this = std::move(*prevScope);  // replace with previous scope
+                }
+                --scope;
+                deleteRef( tables );
+        }
+        Indexer& Indexer::operator= ( const Indexer &that ) {
+                deleteRef( tables );
+                tables = newRef( that.tables );
+                scope = that.scope;
+                doDebug = that.doDebug;
+                return *this;
+        }
+        Indexer& Indexer::operator= ( Indexer &&that ) {
+                deleteRef( tables );
+                tables = that.tables;
+                scope = that.scope;
+                doDebug = that.doDebug;
+                that.tables = 0;
+                return *this;
+        }
         void Indexer::lookupId( const std::string &id, std::list< IdData > &out ) const {
+                ++*stats().lookup_calls;
+                if ( ! idTable ) return;
+                ++*stats().map_lookups;
+                auto decls = idTable->find( id );
+                if ( decls == idTable->end() ) return;
+                for ( auto decl : *(decls->second) ) {
+                        out.push_back( decl.second );
+                }
+                std::unordered_set< std::string > foundMangleNames;
+                Indexer::Impl *searchTables = tables;
+                while ( searchTables ) {
+                        IdTable::const_iterator decls = searchTables->idTable.find( id );
+                        if ( decls != searchTables->idTable.end() ) {
+                                const MangleTable &mangleTable = decls->second;
+                                for ( MangleTable::const_iterator decl = mangleTable.begin(); decl != mangleTable.end(); ++decl ) {
+                                        // mark the mangled name as found, skipping this insertion if a declaration for that name has already been found
+                                        if ( foundMangleNames.insert( decl->first ).second == false ) continue;
+                                        out.push_back( decl->second );
+                                }
+                        }
+                        // get declarations from base indexers
+                        searchTables = searchTables->base.tables;
+                }
+                // some special functions, e.g. constructors and destructors
+                // remove autogenerated functions when they are defined so that
+                // they can never be matched
+                removeSpecialOverrides( id, out );
+        }
         NamedTypeDecl *Indexer::lookupType( const std::string &id ) const {
+                ++*stats().lookup_calls;
+                if ( ! typeTable ) return nullptr;
+                ++*stats().map_lookups;
+                auto it = typeTable->find( id );
+                return it == typeTable->end() ? nullptr : it->second.decl;
+                if ( ! tables ) return 0;
+                TypeTable::const_iterator ret = tables->typeTable.find( id );
+                return ret != tables->typeTable.end() ? ret->second : tables->base.lookupType( id );
+        }
         StructDecl *Indexer::lookupStruct( const std::string &id ) const {
+                ++*stats().lookup_calls;
+                if ( ! structTable ) return nullptr;
+                ++*stats().map_lookups;
+                auto it = structTable->find( id );
+                return it == structTable->end() ? nullptr : it->second.decl;
+                if ( ! tables ) return 0;
+                StructTable::const_iterator ret = tables->structTable.find( id );
+                return ret != tables->structTable.end() ? ret->second : tables->base.lookupStruct( id );
+        }
+        NamedTypeDecl *Indexer::globalLookupType( const std::string &id ) const {
+                return lookupTypeAtScope( id, 0 );
+        }
+        StructDecl *Indexer::globalLookupStruct( const std::string &id ) const {
+                return lookupStructAtScope( id, 0 );
+        }
+        UnionDecl *Indexer::globalLookupUnion( const std::string &id ) const {
+                return lookupUnionAtScope( id, 0 );
+        }
+        EnumDecl *Indexer::globalLookupEnum( const std::string &id ) const {
+                return lookupEnumAtScope( id, 0 );
+        }
         EnumDecl *Indexer::lookupEnum( const std::string &id ) const {
+                ++*stats().lookup_calls;
+                if ( ! enumTable ) return nullptr;
+                ++*stats().map_lookups;
+                auto it = enumTable->find( id );
+                return it == enumTable->end() ? nullptr : it->second.decl;
+                if ( ! tables ) return 0;
+                EnumTable::const_iterator ret = tables->enumTable.find( id );
+                return ret != tables->enumTable.end() ? ret->second : tables->base.lookupEnum( id );
+        }
         UnionDecl *Indexer::lookupUnion( const std::string &id ) const {
+                ++*stats().lookup_calls;
+                if ( ! unionTable ) return nullptr;
+                ++*stats().map_lookups;
+                auto it = unionTable->find( id );
+                return it == unionTable->end() ? nullptr : it->second.decl;
+                if ( ! tables ) return 0;
+                UnionTable::const_iterator ret = tables->unionTable.find( id );
+                return ret != tables->unionTable.end() ? ret->second : tables->base.lookupUnion( id );
+        }
         TraitDecl *Indexer::lookupTrait( const std::string &id ) const {
+                ++*stats().lookup_calls;
+                if ( ! traitTable ) return nullptr;
+                ++*stats().map_lookups;
+                auto it = traitTable->find( id );
+                return it == traitTable->end() ? nullptr : it->second.decl;
+        }
+        const Indexer* Indexer::atScope( unsigned long target ) const {
+                // by lazy construction, final indexer in list has repScope 0, cannot be > target
+                // otherwise, will find first scope representing the target
+                const Indexer* indexer = this;
+                while ( indexer->repScope > target ) {
+                        indexer = indexer->prevScope.get();
+                }
+                return indexer;
+        }
+        NamedTypeDecl *Indexer::globalLookupType( const std::string &id ) const {
+                return atScope( 0 )->lookupType( id );
+        }
+        StructDecl *Indexer::globalLookupStruct( const std::string &id ) const {
+                return atScope( 0 )->lookupStruct( id );
+        }
+        UnionDecl *Indexer::globalLookupUnion( const std::string &id ) const {
+                return atScope( 0 )->lookupUnion( id );
+        }
+        EnumDecl *Indexer::globalLookupEnum( const std::string &id ) const {
+                return atScope( 0 )->lookupEnum( id );
+                if ( ! tables ) return 0;
+                TraitTable::const_iterator ret = tables->traitTable.find( id );
+                return ret != tables->traitTable.end() ? ret->second : tables->base.lookupTrait( id );
+        }
+        const Indexer::IdData * Indexer::lookupIdAtScope( const std::string &id, const std::string &mangleName, unsigned long scope ) const {
+                if ( ! tables ) return nullptr;
+                if ( tables->scope < scope ) return nullptr;
+                IdTable::const_iterator decls = tables->idTable.find( id );
+                if ( decls != tables->idTable.end() ) {
+                        const MangleTable &mangleTable = decls->second;
+                        MangleTable::const_iterator decl = mangleTable.find( mangleName );
+                        if ( decl != mangleTable.end() ) return &decl->second;
+                }
+                return tables->base.lookupIdAtScope( id, mangleName, scope );
+        }
+        Indexer::IdData * Indexer::lookupIdAtScope( const std::string &id, const std::string &mangleName, unsigned long scope ) {
+                return const_cast<IdData *>(const_cast<const Indexer *>(this)->lookupIdAtScope( id, mangleName, scope ));
+        }
+        bool Indexer::hasIncompatibleCDecl( const std::string &id, const std::string &mangleName, unsigned long scope ) const {
+                if ( ! tables ) return false;
+                if ( tables->scope < scope ) return false;
+                IdTable::const_iterator decls = tables->idTable.find( id );
+                if ( decls != tables->idTable.end() ) {
+                        const MangleTable &mangleTable = decls->second;
+                        for ( MangleTable::const_iterator decl = mangleTable.begin(); decl != mangleTable.end(); ++decl ) {
+                                // check for C decls with the same name, skipping those with a compatible type (by mangleName)
+                                if ( ! LinkageSpec::isMangled( decl->second.id->get_linkage() ) && decl->first != mangleName ) return true;
+                        }
+                }
+                return tables->base.hasIncompatibleCDecl( id, mangleName, scope );
+        }
+        bool Indexer::hasCompatibleCDecl( const std::string &id, const std::string &mangleName, unsigned long scope ) const {
+                if ( ! tables ) return false;
+                if ( tables->scope < scope ) return false;
+                IdTable::const_iterator decls = tables->idTable.find( id );
+                if ( decls != tables->idTable.end() ) {
+                        const MangleTable &mangleTable = decls->second;
+                        for ( MangleTable::const_iterator decl = mangleTable.begin(); decl != mangleTable.end(); ++decl ) {
+                                // check for C decls with the same name, skipping
+                                // those with an incompatible type (by mangleName)
+                                if ( ! LinkageSpec::isMangled( decl->second.id->get_linkage() ) && decl->first == mangleName ) return true;
+                        }
+                }
+                return tables->base.hasCompatibleCDecl( id, mangleName, scope );
+        }
+        NamedTypeDecl *Indexer::lookupTypeAtScope( const std::string &id, unsigned long scope ) const {
+                if ( ! tables ) return 0;
+                if ( tables->scope < scope ) return 0;
+                if ( tables->scope > scope ) return tables->base.lookupTypeAtScope( id, scope );
+                TypeTable::const_iterator ret = tables->typeTable.find( id );
+                return ret != tables->typeTable.end() ? ret->second : tables->base.lookupTypeAtScope( id, scope );
+        }
+        StructDecl *Indexer::lookupStructAtScope( const std::string &id, unsigned long scope ) const {
+                if ( ! tables ) return 0;
+                if ( tables->scope < scope ) return 0;
+                if ( tables->scope > scope ) return tables->base.lookupStructAtScope( id, scope );
+                StructTable::const_iterator ret = tables->structTable.find( id );
+                return ret != tables->structTable.end() ? ret->second : tables->base.lookupStructAtScope( id, scope );
+        }
+        EnumDecl *Indexer::lookupEnumAtScope( const std::string &id, unsigned long scope ) const {
+                if ( ! tables ) return 0;
+                if ( tables->scope < scope ) return 0;
+                if ( tables->scope > scope ) return tables->base.lookupEnumAtScope( id, scope );
+                EnumTable::const_iterator ret = tables->enumTable.find( id );
+                return ret != tables->enumTable.end() ? ret->second : tables->base.lookupEnumAtScope( id, scope );
+        }
+        UnionDecl *Indexer::lookupUnionAtScope( const std::string &id, unsigned long scope ) const {
+                if ( ! tables ) return 0;
+                if ( tables->scope < scope ) return 0;
+                if ( tables->scope > scope ) return tables->base.lookupUnionAtScope( id, scope );
+                UnionTable::const_iterator ret = tables->unionTable.find( id );
+                return ret != tables->unionTable.end() ? ret->second : tables->base.lookupUnionAtScope( id, scope );
+        }
+        TraitDecl *Indexer::lookupTraitAtScope( const std::string &id, unsigned long scope ) const {
+                if ( ! tables ) return 0;
+                if ( tables->scope < scope ) return 0;
+                if ( tables->scope > scope ) return tables->base.lookupTraitAtScope( id, scope );
+                TraitTable::const_iterator ret = tables->traitTable.find( id );
+                return ret != tables->traitTable.end() ? ret->second : tables->base.lookupTraitAtScope( id, scope );
+        }
 …
+        }
+        bool Indexer::addedIdConflicts(
+                        const Indexer::IdData & existing, DeclarationWithType *added,
+                        Indexer::OnConflict handleConflicts, BaseSyntaxNode * deleteStmt ) {
+                // if we're giving the same name mangling to things of different types then there is
+                // something wrong
+        bool addedIdConflicts( Indexer::IdData & existing, DeclarationWithType *added, BaseSyntaxNode * deleteStmt, Indexer::ConflictFunction handleConflicts ) {
+                // if we're giving the same name mangling to things of different types then there is something wrong
                 assert( (isObject( added ) && isObject( existing.id ) )
                         || ( isFunction( added ) && isFunction( existing.id ) ) );
                 if ( LinkageSpec::isOverridable( existing.id->linkage ) ) {
+                if ( LinkageSpec::isOverridable( existing.id->get_linkage() ) ) {
                         // new definition shadows the autogenerated one, even at the same scope
                         return false;
+                } else if ( LinkageSpec::isMangled( added->linkage )
+                                || ResolvExpr::typesCompatible(
+                                        added->get_type(), existing.id->get_type(), Indexer() ) ) {
+                } else if ( LinkageSpec::isMangled( added->get_linkage() ) || ResolvExpr::typesCompatible( added->get_type(), existing.id->get_type(), Indexer() ) ) {
                         // it is a conflict if one declaration is deleted and the other is not
                         if ( deleteStmt && ! existing.deleteStmt ) {
+                                if ( handleConflicts.mode == OnConflict::Error ) {
+                                        SemanticError( added, "deletion of defined identifier " );
+                                }
+                                return true;
+                                return handleConflicts( existing, "deletion of defined identifier " );
                         } else if ( ! deleteStmt && existing.deleteStmt ) {
+                                if ( handleConflicts.mode == OnConflict::Error ) {
+                                        SemanticError( added, "definition of deleted identifier " );
+                                }
+                                return true;
+                                return handleConflicts( existing, "definition of deleted identifier " );
+                        }
                         if ( isDefinition( added ) && isDefinition( existing.id ) ) {
+                                if ( handleConflicts.mode == OnConflict::Error ) {
+                                        SemanticError( added,
+                                                isFunction( added ) ?
+                                                        "duplicate function definition for " :
+                                                        "duplicate object definition for " );
+                                }
+                                return true;
+                                if ( isFunction( added ) ) {
+                                        return handleConflicts( existing, "duplicate function definition for " );
+                                } else {
+                                        return handleConflicts( existing, "duplicate object definition for " );
+                                } // if
                         } // if
                 } else {
+                        if ( handleConflicts.mode == OnConflict::Error ) {
+                                SemanticError( added, "duplicate definition for " );
+                        }
+                        return true;
+                        return handleConflicts( existing, "duplicate definition for " );
                 } // if
 …
+        }
+        bool Indexer::hasCompatibleCDecl( const std::string &id, const std::string &mangleName ) const {
+                if ( ! idTable ) return false;
+                ++*stats().map_lookups;
+                auto decls = idTable->find( id );
+                if ( decls == idTable->end() ) return false;
+                for ( auto decl : *(decls->second) ) {
+                        // skip other scopes (hidden by this decl)
+                        if ( decl.second.scope != scope ) continue;
+                        // check for C decl with compatible type (by mangleName)
+                        if ( ! LinkageSpec::isMangled( decl.second.id->linkage ) && decl.first == mangleName ) {
+                                return true;
+                        }
+                }
+                return false;
+        }
+        bool Indexer::hasIncompatibleCDecl(
+                        const std::string &id, const std::string &mangleName ) const {
+                if ( ! idTable ) return false;
+                ++*stats().map_lookups;
+                auto decls = idTable->find( id );
+                if ( decls == idTable->end() ) return false;
+                for ( auto decl : *(decls->second) ) {
+                        // skip other scopes (hidden by this decl)
+                        if ( decl.second.scope != scope ) continue;
+                        // check for C decl with incompatible type (by manglename)
+                        if ( ! LinkageSpec::isMangled( decl.second.id->linkage ) && decl.first != mangleName ) {
+                                return true;
+                        }
+                }
+                return false;
+        }
+        /// gets the base type of the first parameter; decl must be a ctor/dtor/assignment function
+        std::string getOtypeKey( FunctionDecl* function ) {
+                auto& params = function->type->parameters;
+                assert( ! params.empty() );
+                // use base type of pointer, so that qualifiers on the pointer type aren't considered.
+                Type* base = InitTweak::getPointerBase( params.front()->get_type() );
+                assert( base );
+                return Mangler::mangle( base );
+        }
+        /// gets the declaration for the function acting on a type specified by otype key,
+        /// nullptr if none such
+        FunctionDecl * getFunctionForOtype( DeclarationWithType * decl, const std::string& otypeKey ) {
+                FunctionDecl * func = dynamic_cast< FunctionDecl * >( decl );
+                if ( ! func || otypeKey != getOtypeKey( func ) ) return nullptr;
+                return func;
+        }
+        bool Indexer::removeSpecialOverrides(
+                        Indexer::IdData& data, Indexer::MangleTable::Ptr& mangleTable ) {
+                // if a type contains user defined ctor/dtor/assign, then special rules trigger, which
+                // determinethe set of ctor/dtor/assign that can be used  by the requester. In particular,
+                // if the user defines a default ctor, then the generated default ctor is unavailable,
+                // likewise for copy ctor and dtor. If the user defines any ctor/dtor, then no generated
+                // field ctors are available. If the user defines any ctor then the generated default ctor
+                // is unavailable (intrinsic default ctor must be overridden exactly). If the user defines
+                // anything that looks like a copy constructor, then the generated copy constructor is
+                // unavailable, and likewise for the assignment operator.
+                // only relevant on function declarations
+                FunctionDecl * function = dynamic_cast< FunctionDecl * >( data.id );
+                if ( ! function ) return true;
+                // only need to perform this check for constructors, destructors, and assignment functions
+                if ( ! CodeGen::isCtorDtorAssign( data.id->name ) ) return true;
+                // set up information for this type
+                bool dataIsUserDefinedFunc = ! LinkageSpec::isOverridable( function->linkage );
+                bool dataIsCopyFunc = InitTweak::isCopyFunction( function, function->name );
+                std::string dataOtypeKey = getOtypeKey( function );
+                if ( dataIsUserDefinedFunc && dataIsCopyFunc ) {
+                        // this is a user-defined copy function
+                        // if this is the first such, delete/remove non-user-defined overloads as needed
+                        std::vector< std::string > removed;
+                        std::vector< MangleTable::value_type > deleted;
+                        bool alreadyUserDefinedFunc = false;
+                        for ( const auto& entry : *mangleTable ) {
+                                // skip decls that aren't functions or are for the wrong type
+                                FunctionDecl * decl = getFunctionForOtype( entry.second.id, dataOtypeKey );
+                                if ( ! decl ) continue;
+                                bool isCopyFunc = InitTweak::isCopyFunction( decl, decl->name );
+                                if ( ! LinkageSpec::isOverridable( decl->linkage ) ) {
+                                        // matching user-defined function
+                                        if ( isCopyFunc ) {
+                                                // mutation already performed, return early
+                                                return true;
+                                        } else {
+                                                // note that non-copy deletions already performed
+                                                alreadyUserDefinedFunc = true;
+                                        }
+                                } else {
+                                        // non-user-defined function; mark for deletion/removal as appropriate
+                                        if ( isCopyFunc ) {
+                                                removed.push_back( entry.first );
+                                        } else if ( ! alreadyUserDefinedFunc ) {
+                                                deleted.push_back( entry );
+                                        }
+                                }
+                        }
+                        // perform removals from mangle table, and deletions if necessary
+                        for ( const auto& key : removed ) {
+                                ++*stats().map_mutations;
+                                mangleTable = mangleTable->erase( key );
+                        }
+                        if ( ! alreadyUserDefinedFunc ) for ( const auto& entry : deleted ) {
+                                ++*stats().map_mutations;
+                                mangleTable = mangleTable->set( entry.first, IdData{ entry.second, function } );
+                        }
+                } else if ( dataIsUserDefinedFunc ) {
+                        // this is a user-defined non-copy function
+                        // if this is the first user-defined function, delete non-user-defined overloads
+                        std::vector< MangleTable::value_type > deleted;
+                        for ( const auto& entry : *mangleTable ) {
+                                // skip decls that aren't functions or are for the wrong type
+                                FunctionDecl * decl = getFunctionForOtype( entry.second.id, dataOtypeKey );
+                                if ( ! decl ) continue;
+                                // exit early if already a matching user-defined function;
+                                // earlier function will have mutated table
+                                if ( ! LinkageSpec::isOverridable( decl->linkage ) ) return true;
+                                // skip mutating intrinsic functions
+                                if ( decl->linkage == LinkageSpec::Intrinsic ) continue;
+                                // user-defined non-copy functions do not override copy functions
+                                if ( InitTweak::isCopyFunction( decl, decl->name ) ) continue;
+                                // this function to be deleted after mangleTable iteration is complete
+                                deleted.push_back( entry );
+                        }
+                        // mark deletions to update mangle table
+                        // this needs to be a separate loop because of iterator invalidation
+                        for ( const auto& entry : deleted ) {
+                                ++*stats().map_mutations;
+                                mangleTable = mangleTable->set( entry.first, IdData{ entry.second, function } );
+                        }
+                } else if ( function->linkage != LinkageSpec::Intrinsic ) {
+                        // this is an overridable generated function
+                        // if there already exists a matching user-defined function, delete this appropriately
+                        for ( const auto& entry : *mangleTable ) {
+                                // skip decls that aren't functions or are for the wrong type
+                                FunctionDecl * decl = getFunctionForOtype( entry.second.id, dataOtypeKey );
+                                if ( ! decl ) continue;
+                                // skip non-user-defined functions
+                                if ( LinkageSpec::isOverridable( decl->linkage ) ) continue;
+                                if ( dataIsCopyFunc ) {
+                                        // remove current function if exists a user-defined copy function
+                                        // since the signatures for copy functions don't need to match exactly, using
+                                        // a delete statement is the wrong approach
+                                        if ( InitTweak::isCopyFunction( decl, decl->name ) ) return false;
+                                } else {
+                                        // mark current function deleted by first user-defined function found
+                                        data.deleteStmt = decl;
+                                        return true;
+                                }
+                        }
+                }
+                // nothing (more) to fix, return true
+                return true;
+        }
+        void Indexer::addId(
+                        DeclarationWithType *decl, OnConflict handleConflicts, Expression * baseExpr,
+                        BaseSyntaxNode * deleteStmt ) {
+                ++*stats().add_calls;
+        void Indexer::addId( DeclarationWithType *decl, ConflictFunction handleConflicts, Expression * baseExpr, BaseSyntaxNode * deleteStmt ) {
+                if ( decl->name == "" ) return;
+                debugPrint( "Adding Id " << decl->name << std::endl );
+                makeWritable();
                 const std::string &name = decl->name;
-                if ( name == "" ) return;
                 std::string mangleName;
                 if ( LinkageSpec::isOverridable( decl->linkage ) ) {
                         // mangle the name without including the appropriate suffix, so overridable routines
                         // are placed into the same "bucket" as their user defined versions.
+                        // mangle the name without including the appropriate suffix, so overridable routines are placed into the
+                        // same "bucket" as their user defined versions.
                         mangleName = Mangler::mangle( decl, false );
                 } else {
 …
                 } // if
+                // this ensures that no two declarations with the same unmangled name at the same scope
+                // both have C linkage
+                if ( LinkageSpec::isMangled( decl->linkage ) ) {
+                // this ensures that no two declarations with the same unmangled name at the same scope both have C linkage
+                if ( ! LinkageSpec::isMangled( decl->linkage ) ) {
+                        // NOTE this is broken in Richard's original code in such a way that it never triggers (it
+                        // doesn't check decls that have the same manglename, and all C-linkage decls are defined to
+                        // have their name as their manglename, hence the error can never trigger).
+                        // The code here is closer to correct, but name mangling would have to be completely
+                        // isomorphic to C type-compatibility, which it may not be.
+                        if ( hasIncompatibleCDecl( name, mangleName, scope ) ) {
+                                SemanticError( decl, "conflicting overload of C function " );
+                        }
+                } else {
                         // Check that a Cforall declaration doesn't override any C declaration
                         if ( hasCompatibleCDecl( name, mangleName ) ) {
+                        if ( hasCompatibleCDecl( name, mangleName, scope ) ) {
                                 SemanticError( decl, "Cforall declaration hides C function " );
+                        }
+                } else {
+                        // NOTE: only correct if name mangling is completely isomorphic to C
+                        // type-compatibility, which it may not be.
+                        if ( hasIncompatibleCDecl( name, mangleName ) ) {
+                                SemanticError( decl, "conflicting overload of C function " );
+                        }
+                }
+                // ensure tables exist and add identifier
+                MangleTable::Ptr mangleTable;
+                if ( ! idTable ) {
+                        idTable = IdTable::new_ptr();
+                        mangleTable = MangleTable::new_ptr();
+                } else {
+                        ++*stats().map_lookups;
+                        auto decls = idTable->find( name );
+                        if ( decls == idTable->end() ) {
+                                mangleTable = MangleTable::new_ptr();
+                        } else {
+                                mangleTable = decls->second;
+                                // skip in-scope repeat declarations of same identifier
+                                ++*stats().map_lookups;
+                                auto existing = mangleTable->find( mangleName );
+                                if ( existing != mangleTable->end()
+                                                && existing->second.scope == scope
+                                                && existing->second.id ) {
+                                        if ( addedIdConflicts( existing->second, decl, handleConflicts, deleteStmt ) ) {
+                                                if ( handleConflicts.mode == OnConflict::Delete ) {
+                                                        // set delete expression for conflicting identifier
+                                                        lazyInitScope();
+                                                        *stats().map_mutations += 2;
+                                                        idTable = idTable->set(
+                                                                name,
+                                                                mangleTable->set(
+                                                                        mangleName,
+                                                                        IdData{ existing->second, handleConflicts.deleteStmt } ) );
+                                                }
+                                                return;
+                                        }
+                                }
+                        }
+                }
+                // add/overwrite with new identifier
+                lazyInitScope();
+                IdData data{ decl, baseExpr, deleteStmt, scope };
+                // Ensure that auto-generated ctor/dtor/assignment are deleted if necessary
+                if ( ! removeSpecialOverrides( data, mangleTable ) ) return;
+                *stats().map_mutations += 2;
+                idTable = idTable->set( name, mangleTable->set( mangleName, std::move(data) ) );
+                }
+                // Skip repeat declarations of the same identifier
+                IdData * existing = lookupIdAtScope( name, mangleName, scope );
+                if ( existing && existing->id && addedIdConflicts( *existing, decl, deleteStmt, handleConflicts ) ) return;
+                // add to indexer
+                tables->idTable[ name ][ mangleName ] = IdData{ decl, baseExpr, deleteStmt };
+                ++tables->size;
+        }
         void Indexer::addId( DeclarationWithType * decl, Expression * baseExpr ) {
                 // default handling of conflicts is to raise an error
                 addId( decl, OnConflict::error(), baseExpr, decl->isDeleted ? decl : nullptr );
+                addId( decl, [decl](IdData &, const std::string & msg) { SemanticError( decl, msg ); return true; }, baseExpr, decl->isDeleted ? decl : nullptr );
+        }
         void Indexer::addDeletedId( DeclarationWithType * decl, BaseSyntaxNode * deleteStmt ) {
                 // default handling of conflicts is to raise an error
                 addId( decl, OnConflict::error(), nullptr, deleteStmt );
+                addId( decl, [decl](IdData &, const std::string & msg) { SemanticError( decl, msg ); return true; }, nullptr, deleteStmt );
+        }
 …
+                        }
+                }
+                // does not need to be added to the table if both existing and added have a base that are
+                // the same
+                // does not need to be added to the table if both existing and added have a base that are the same
                 return true;
+        }
         void Indexer::addType( NamedTypeDecl *decl ) {
+                ++*stats().add_calls;
+                debugPrint( "Adding type " << decl->name << std::endl );
+                makeWritable();
                 const std::string &id = decl->name;
+                if ( ! typeTable ) {
+                        typeTable = TypeTable::new_ptr();
+                } else {
+                        ++*stats().map_lookups;
+                        auto existing = typeTable->find( id );
+                        if ( existing != typeTable->end()
+                                && existing->second.scope == scope
+                                && addedTypeConflicts( existing->second.decl, decl ) ) return;
+                }
+                lazyInitScope();
+                ++*stats().map_mutations;
+                typeTable = typeTable->set( id, Scoped<NamedTypeDecl>{ decl, scope } );
+                TypeTable::iterator existing = tables->typeTable.find( id );
+                if ( existing == tables->typeTable.end() ) {
+                        NamedTypeDecl *parent = tables->base.lookupTypeAtScope( id, scope );
+                        if ( ! parent || ! addedTypeConflicts( parent, decl ) ) {
+                                tables->typeTable.insert( existing, std::make_pair( id, decl ) );
+                                ++tables->size;
+                        }
+                } else {
+                        if ( ! addedTypeConflicts( existing->second, decl ) ) {
+                                existing->second = decl;
+                        }
+                }
+        }
 …
         void Indexer::addStruct( const std::string &id ) {
+                debugPrint( "Adding fwd decl for struct " << id << std::endl );
                 addStruct( new StructDecl( id ) );
+        }
         void Indexer::addStruct( StructDecl *decl ) {
+                ++*stats().add_calls;
+                debugPrint( "Adding struct " << decl->name << std::endl );
+                makeWritable();
                 const std::string &id = decl->name;
+                if ( ! structTable ) {
+                        structTable = StructTable::new_ptr();
+                } else {
+                        ++*stats().map_lookups;
+                        auto existing = structTable->find( id );
+                        if ( existing != structTable->end()
+                                && existing->second.scope == scope
+                                && addedDeclConflicts( existing->second.decl, decl ) ) return;
+                }
+                lazyInitScope();
+                ++*stats().map_mutations;
+                structTable = structTable->set( id, Scoped<StructDecl>{ decl, scope } );
+                StructTable::iterator existing = tables->structTable.find( id );
+                if ( existing == tables->structTable.end() ) {
+                        StructDecl *parent = tables->base.lookupStructAtScope( id, scope );
+                        if ( ! parent || ! addedDeclConflicts( parent, decl ) ) {
+                                tables->structTable.insert( existing, std::make_pair( id, decl ) );
+                                ++tables->size;
+                        }
+                } else {
+                        if ( ! addedDeclConflicts( existing->second, decl ) ) {
+                                existing->second = decl;
+                        }
+                }
+        }
         void Indexer::addEnum( EnumDecl *decl ) {
+                ++*stats().add_calls;
+                debugPrint( "Adding enum " << decl->name << std::endl );
+                makeWritable();
                 const std::string &id = decl->name;
+                if ( ! enumTable ) {
+                        enumTable = EnumTable::new_ptr();
+                } else {
+                        ++*stats().map_lookups;
+                        auto existing = enumTable->find( id );
+                        if ( existing != enumTable->end()
+                                && existing->second.scope == scope
+                                && addedDeclConflicts( existing->second.decl, decl ) ) return;
+                }
+                lazyInitScope();
+                ++*stats().map_mutations;
+                enumTable = enumTable->set( id, Scoped<EnumDecl>{ decl, scope } );
+                EnumTable::iterator existing = tables->enumTable.find( id );
+                if ( existing == tables->enumTable.end() ) {
+                        EnumDecl *parent = tables->base.lookupEnumAtScope( id, scope );
+                        if ( ! parent || ! addedDeclConflicts( parent, decl ) ) {
+                                tables->enumTable.insert( existing, std::make_pair( id, decl ) );
+                                ++tables->size;
+                        }
+                } else {
+                        if ( ! addedDeclConflicts( existing->second, decl ) ) {
+                                existing->second = decl;
+                        }
+                }
+        }
         void Indexer::addUnion( const std::string &id ) {
+                debugPrint( "Adding fwd decl for union " << id << std::endl );
                 addUnion( new UnionDecl( id ) );
+        }
         void Indexer::addUnion( UnionDecl *decl ) {
+                ++*stats().add_calls;
+                debugPrint( "Adding union " << decl->name << std::endl );
+                makeWritable();
                 const std::string &id = decl->name;
+                if ( ! unionTable ) {
+                        unionTable = UnionTable::new_ptr();
+                } else {
+                        ++*stats().map_lookups;
+                        auto existing = unionTable->find( id );
+                        if ( existing != unionTable->end()
+                                && existing->second.scope == scope
+                                && addedDeclConflicts( existing->second.decl, decl ) ) return;
+                }
+                lazyInitScope();
+                ++*stats().map_mutations;
+                unionTable = unionTable->set( id, Scoped<UnionDecl>{ decl, scope } );
+                UnionTable::iterator existing = tables->unionTable.find( id );
+                if ( existing == tables->unionTable.end() ) {
+                        UnionDecl *parent = tables->base.lookupUnionAtScope( id, scope );
+                        if ( ! parent || ! addedDeclConflicts( parent, decl ) ) {
+                                tables->unionTable.insert( existing, std::make_pair( id, decl ) );
+                                ++tables->size;
+                        }
+                } else {
+                        if ( ! addedDeclConflicts( existing->second, decl ) ) {
+                                existing->second = decl;
+                        }
+                }
+        }
         void Indexer::addTrait( TraitDecl *decl ) {
+                ++*stats().add_calls;
+                debugPrint( "Adding trait " << decl->name << std::endl );
+                makeWritable();
                 const std::string &id = decl->name;
+                if ( ! traitTable ) {
+                        traitTable = TraitTable::new_ptr();
+                } else {
+                        ++*stats().map_lookups;
+                        auto existing = traitTable->find( id );
+                        if ( existing != traitTable->end()
+                                && existing->second.scope == scope
+                                && addedDeclConflicts( existing->second.decl, decl ) ) return;
+                }
+                lazyInitScope();
+                ++*stats().map_mutations;
+                traitTable = traitTable->set( id, Scoped<TraitDecl>{ decl, scope } );
+        }
+        void Indexer::addMembers( AggregateDecl * aggr, Expression * expr,
+                        OnConflict handleConflicts ) {
+                TraitTable::iterator existing = tables->traitTable.find( id );
+                if ( existing == tables->traitTable.end() ) {
+                        TraitDecl *parent = tables->base.lookupTraitAtScope( id, scope );
+                        if ( ! parent || ! addedDeclConflicts( parent, decl ) ) {
+                                tables->traitTable.insert( existing, std::make_pair( id, decl ) );
+                                ++tables->size;
+                        }
+                } else {
+                        if ( ! addedDeclConflicts( existing->second, decl ) ) {
+                                existing->second = decl;
+                        }
+                }
+        }
+        void Indexer::addMembers( AggregateDecl * aggr, Expression * expr, ConflictFunction handleConflicts ) {
                 for ( Declaration * decl : aggr->members ) {
                         if ( DeclarationWithType * dwt = dynamic_cast< DeclarationWithType * >( decl ) ) {
 …
                                 if ( dwt->name == "" ) {
                                         Type * t = dwt->get_type()->stripReferences();
                                         if ( dynamic_cast<StructInstType*>( t ) || dynamic_cast<UnionInstType*>( t ) ) {
+                                        if ( dynamic_cast< StructInstType * >( t ) || dynamic_cast< UnionInstType * >( t ) ) {
                                                 Expression * base = expr->clone();
                                                 ResolvExpr::Cost cost = ResolvExpr::Cost::zero; // xxx - carry this cost into the indexer as a base cost?
 …
                                 assertf( aggr, "WithStmt expr has non-aggregate type: %s", toString( expr->result ).c_str() );
+                                addMembers( aggr, expr, OnConflict::deleteWith( withStmt ) );
+                                addMembers( aggr, expr, [withStmt](IdData & existing, const std::string &) {
+                                        // on conflict, delete the identifier
+                                        existing.deleteStmt = withStmt;
+                                        return true;
+                                });
+                        }
+                }
 …
                 addIds( ftype->returnVals );
                 addIds( ftype->parameters );
+        }
+        void Indexer::enterScope() {
+                ++scope;
+                if ( doDebug ) {
+                        std::cerr << "--- Entering scope " << scope << std::endl;
+                }
+        }
+        void Indexer::leaveScope() {
+                using std::cerr;
+                assert( scope > 0 && "cannot leave initial scope" );
+                if ( doDebug ) {
+                        cerr << "--- Leaving scope " << scope << " containing" << std::endl;
+                }
+                --scope;
+                while ( tables && tables->scope > scope ) {
+                        if ( doDebug ) {
+                                dump( tables->idTable, cerr );
+                                dump( tables->typeTable, cerr );
+                                dump( tables->structTable, cerr );
+                                dump( tables->enumTable, cerr );
+                                dump( tables->unionTable, cerr );
+                                dump( tables->traitTable, cerr );
+                        }
+                        // swap tables for base table until we find one at an appropriate scope
+                        Indexer::Impl *base = newRef( tables->base.tables );
+                        deleteRef( tables );
+                        tables = base;
+                }
+        }
+        void Indexer::print( std::ostream &os, int indent ) const {
+                using std::cerr;
+                if ( tables ) {
+                        os << "--- scope " << tables->scope << " ---" << std::endl;
+                        os << "===idTable===" << std::endl;
+                        dump( tables->idTable, os );
+                        os << "===typeTable===" << std::endl;
+                        dump( tables->typeTable, os );
+                        os << "===structTable===" << std::endl;
+                        dump( tables->structTable, os );
+                        os << "===enumTable===" << std::endl;
+                        dump( tables->enumTable, os );
+                        os << "===unionTable===" << std::endl;
+                        dump( tables->unionTable, os );
+                        os << "===contextTable===" << std::endl;
+                        dump( tables->traitTable, os );
+                        tables->base.print( os, indent );
+                } else {
+                        os << "--- end ---" << std::endl;
+                }
+        }

src/SymTab/Indexer.h

-              r933f32f
+              r6a9d4b4
 // Author           : Richard C. Bilson
 // Created On       : Sun May 17 21:38:55 2015
 // Last Modified By : Aaron B. Moss
 // Last Modified On : Fri Mar  8 13:55:00 2019
 // Update Count     : 9
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Thu Aug 17 16:09:12 2017
+// Update Count     : 8
 //
 #pragma once
 #include <functional>              // for function
 #include <list>                    // for list
 #include <memory>                  // for shared_ptr, enable_shared_from_this
 #include <string>                  // for string
+#include <iosfwd>             // for ostream
+#include <list>               // for list
+#include <string>             // for string
+#include <functional>         // for function
 #include "Common/PersistentMap.h"  // for PersistentMap
 #include "SynTree/SynTree.h"       // for AST nodes
+#include "SynTree/Visitor.h"  // for Visitor
+#include "SynTree/SynTree.h"  // for AST nodes
 namespace ResolvExpr {
         class Cost;
+class Cost;
+}
 namespace SymTab {
         class Indexer : public std::enable_shared_from_this<SymTab::Indexer> {
         public:
+        class Indexer {
+          public:
                 explicit Indexer();
+                Indexer( const Indexer &that );
+                Indexer( Indexer &&that );
                 virtual ~Indexer();
+                Indexer& operator= ( const Indexer &that );
+                Indexer& operator= ( Indexer &&that );
                 // when using an indexer manually (e.g., within a mutator traversal), it is necessary to
                 // tell the indexer explicitly when scopes begin and end
+                // when using an indexer manually (e.g., within a mutator traversal), it is necessary to tell the indexer
+                // explicitly when scopes begin and end
                 void enterScope();
                 void leaveScope();
 …
                         /// non-null if this declaration is deleted
                         BaseSyntaxNode * deleteStmt = nullptr;
-                        /// scope of identifier
-                        unsigned long scope = 0;
                         // NOTE: shouldn't need either of these constructors, but gcc-4 does not properly support initializer lists with default members.
                         IdData() = default;
+                        IdData(
+                                DeclarationWithType * id, Expression * baseExpr, BaseSyntaxNode * deleteStmt,
+                                unsigned long scope )
+                                : id( id ), baseExpr( baseExpr ), deleteStmt( deleteStmt ), scope( scope ) {}
+                        IdData( const IdData& o, BaseSyntaxNode * deleteStmt )
+                                : id( o.id ), baseExpr( o.baseExpr ), deleteStmt( deleteStmt ), scope( o.scope ) {}
+                        IdData( DeclarationWithType * id, Expression * baseExpr, BaseSyntaxNode * deleteStmt ) : id( id ), baseExpr( baseExpr ), deleteStmt( deleteStmt ) {}
                         Expression * combine( ResolvExpr::Cost & cost ) const;
 …
                 EnumDecl *globalLookupEnum( const std::string &id ) const;
+                void print( std::ostream &os, int indent = 0 ) const;
+                /// looks up a specific mangled ID at the given scope
+                IdData * lookupIdAtScope( const std::string &id, const std::string &mangleName, unsigned long scope );
+                const IdData * lookupIdAtScope( const std::string &id, const std::string &mangleName, unsigned long scope ) const;
+                /// returns true if there exists a declaration with C linkage and the given name with a different mangled name
+                bool hasIncompatibleCDecl( const std::string &id, const std::string &mangleName, unsigned long scope ) const;
+                /// returns true if there exists a declaration with C linkage and the given name with the same mangled name
+                bool hasCompatibleCDecl( const std::string &id, const std::string &mangleName, unsigned long scope ) const;
+                // equivalents to lookup functions that only look at tables at scope `scope` (which should be >= tables->scope)
+                NamedTypeDecl *lookupTypeAtScope( const std::string &id, unsigned long scope ) const;
+                StructDecl *lookupStructAtScope( const std::string &id, unsigned long scope ) const;
+                EnumDecl *lookupEnumAtScope( const std::string &id, unsigned long scope ) const;
+                UnionDecl *lookupUnionAtScope( const std::string &id, unsigned long scope ) const;
+                TraitDecl *lookupTraitAtScope( const std::string &id, unsigned long scope ) const;
+                typedef std::function<bool(IdData &, const std::string &)> ConflictFunction;
                 void addId( DeclarationWithType * decl, Expression * baseExpr = nullptr );
                 void addDeletedId( DeclarationWithType * decl, BaseSyntaxNode * deleteStmt );
 …
                 void addWith( std::list< Expression * > & withExprs, BaseSyntaxNode * withStmt );
+                /// adds all of the members of the Aggregate (addWith helper)
+                void addMembers( AggregateDecl * aggr, Expression * expr, ConflictFunction );
                 /// convenience function for adding a list of Ids to the indexer
                 void addIds( const std::list< DeclarationWithType * > & decls );
 …
                 void addFunctionType( FunctionType * ftype );
+                bool doDebug = false; ///< Display debugging trace?
           private:
+                /// Wraps a Decl* with a scope
+                template<typename Decl>
+                struct Scoped {
+                        Decl* decl;           ///< declaration
+                        unsigned long scope;  ///< scope of this declaration
+                struct Impl;
                         Scoped(Decl* d, unsigned long s) : decl(d), scope(s) {}
                 };
+                Impl *tables;         ///< Copy-on-write instance of table data structure
+                unsigned long scope;  ///< Scope index of this pointer
+                using Ptr = std::shared_ptr<const Indexer>;
+                /// Takes a new ref to a table (returns null if null)
+                static Impl *newRef( Impl *toClone );
+                /// Clears a ref to a table (does nothing if null)
+                static void deleteRef( Impl *toFree );
+                using MangleTable = PersistentMap< std::string, IdData >;
+                using IdTable = PersistentMap< std::string, MangleTable::Ptr >;
+                using TypeTable = PersistentMap< std::string, Scoped<NamedTypeDecl> >;
+                using StructTable = PersistentMap< std::string, Scoped<StructDecl> >;
+                using EnumTable = PersistentMap< std::string, Scoped<EnumDecl> >;
+                using UnionTable = PersistentMap< std::string, Scoped<UnionDecl> >;
+                using TraitTable = PersistentMap< std::string, Scoped<TraitDecl> >;
+                // Removes matching autogenerated constructors and destructors
+                // so that they will not be selected
+                // void removeSpecialOverrides( FunctionDecl *decl );
+                void removeSpecialOverrides( const std::string &id, std::list< IdData > & out ) const;
+                IdTable::Ptr idTable;          ///< identifier namespace
+                TypeTable::Ptr typeTable;      ///< type namespace
+                StructTable::Ptr structTable;  ///< struct namespace
+                EnumTable::Ptr enumTable;      ///< enum namespace
+                UnionTable::Ptr unionTable;    ///< union namespace
+                TraitTable::Ptr traitTable;    ///< trait namespace
+                Ptr prevScope;                 ///< reference to indexer for parent scope
+                unsigned long scope;           ///< Scope index of this indexer
+                unsigned long repScope;        ///< Scope index of currently represented scope
+                /// Ensures that a proper backtracking scope exists before a mutation
+                void lazyInitScope();
+                /// Gets the indexer at the given scope
+                const Indexer* atScope( unsigned long scope ) const;
+                /// Removes matching autogenerated constructors and destructors so that they will not be
+                /// selected. If returns false, passed decl should not be added.
+                bool removeSpecialOverrides( IdData& decl, MangleTable::Ptr& mangleTable );
+                /// Options for handling identifier conflicts
+                struct OnConflict {
+                        enum {
+                                Error,  ///< Throw a semantic error
+                                Delete  ///< Delete the earlier version with the delete statement
+                        } mode;
+                        BaseSyntaxNode * deleteStmt;  ///< Statement that deletes this expression
+                private:
+                        OnConflict() : mode(Error), deleteStmt(nullptr) {}
+                        OnConflict( BaseSyntaxNode * d ) : mode(Delete), deleteStmt(d) {}
+                public:
+                        OnConflict( const OnConflict& ) = default;
+                        static OnConflict error() { return {}; }
+                        static OnConflict deleteWith( BaseSyntaxNode * d ) { return { d }; }
+                };
+                /// true if the existing identifier conflicts with the added identifier
+                bool addedIdConflicts(
+                        const IdData& existing, DeclarationWithType * added, OnConflict handleConflicts,
+                        BaseSyntaxNode * deleteStmt );
+                /// Ensures that tables variable is writable (i.e. allocated, uniquely owned by this Indexer, and at the current scope)
+                void makeWritable();
                 /// common code for addId, addDeletedId, etc.
+                void addId(
+                        DeclarationWithType * decl, OnConflict handleConflicts,
+                        Expression * baseExpr = nullptr, BaseSyntaxNode * deleteStmt = nullptr );
+                /// adds all of the members of the Aggregate (addWith helper)
+                void addMembers( AggregateDecl * aggr, Expression * expr, OnConflict handleConflicts );
+                /// returns true if there exists a declaration with C linkage and the given name with the same mangled name
+                bool hasCompatibleCDecl( const std::string &id, const std::string &mangleName ) const;
+                /// returns true if there exists a declaration with C linkage and the given name with a different mangled name
+                bool hasIncompatibleCDecl( const std::string &id, const std::string &mangleName ) const;
+                void addId( DeclarationWithType * decl, ConflictFunction, Expression * baseExpr = nullptr, BaseSyntaxNode * deleteStmt = nullptr );
         };
 } // namespace SymTab

src/SymTab/Mangler.cc

-              r933f32f
+              r6a9d4b4
                         struct Mangler : public WithShortCircuiting, public WithVisitorRef<Mangler>, public WithGuards {
                                 Mangler( bool mangleOverridable, bool typeMode, bool mangleGenericParams );
+                                Mangler( const ResolvExpr::TypeEnvironment& env );
                                 Mangler( const Mangler & ) = delete;
 …
                           private:
                                 std::ostringstream mangleName;  ///< Mangled name being constructed
                                 typedef std::map< std::string, std::pair< int, int > > VarMapType;
+                                typedef std::map< std::string, std::pair< std::string, int > > VarMapType;
                                 VarMapType varNums;             ///< Map of type variables to indices
                                 int nextVarNum;                 ///< Next type variable index
+                                const ResolvExpr::TypeEnvironment* env;  ///< optional environment for substitutions
                                 bool isTopLevel;                ///< Is the Mangler at the top level
                                 bool mangleOverridable;         ///< Specially mangle overridable built-in methods
 …
                           public:
                                 Mangler( bool mangleOverridable, bool typeMode, bool mangleGenericParams,
+                                        int nextVarNum, const VarMapType& varNums );
+                                        int nextVarNum, const ResolvExpr::TypeEnvironment* env,
+                                        const VarMapType& varNums );
                           private:
 …
+                }
+                std::string mangleAssnKey( DeclarationWithType* decl,
+                                const ResolvExpr::TypeEnvironment& env ) {
+                        PassVisitor<Mangler> mangler( env );
+                        maybeAccept( decl, mangler );
+                        return mangler.pass.get_mangleName();
+                }
                 namespace {
                         Mangler::Mangler( bool mangleOverridable, bool typeMode, bool mangleGenericParams )
                                 : nextVarNum( 0 ), isTopLevel( true ),
+                                : nextVarNum( 0 ), env(nullptr), isTopLevel( true ),
                                 mangleOverridable( mangleOverridable ), typeMode( typeMode ),
                                 mangleGenericParams( mangleGenericParams ) {}
+                        Mangler::Mangler( const ResolvExpr::TypeEnvironment& env )
+                                : nextVarNum( 0 ), env( &env ), isTopLevel( true ), mangleOverridable( false ),
+                                typeMode( false ), mangleGenericParams( true ) {}
                         Mangler::Mangler( bool mangleOverridable, bool typeMode, bool mangleGenericParams,
+                                int nextVarNum, const VarMapType& varNums )
+                                : varNums( varNums ), nextVarNum( nextVarNum ), isTopLevel( false ),
+                                int nextVarNum, const ResolvExpr::TypeEnvironment* env,
+                                const VarMapType& varNums )
+                                : varNums( varNums ), nextVarNum( nextVarNum ), env( env ), isTopLevel( false ),
                                 mangleOverridable( mangleOverridable ), typeMode( typeMode ),
                                 mangleGenericParams( mangleGenericParams ) {}
 …
                                                         assert( false );
                                                 } // switch
+                                                varNums[ (*i)->name ] = std::make_pair( nextVarNum, (int)(*i)->get_kind() );
+                                                std::string varName;
+                                                // replace type with substitution name if environment is available and bound
+                                                if ( env ) {
+                                                        const ResolvExpr::EqvClass* varClass = env->lookup( (*i)->name );
+                                                        if ( varClass && varClass->type ) {
+                                                                PassVisitor<Mangler> sub_mangler(
+                                                                        mangleOverridable, typeMode, mangleGenericParams, nextVarNum,
+                                                                        env, varNums );
+                                                                varClass->type->accept( sub_mangler );
+                                                                varName = std::string{"%"} + sub_mangler.pass.get_mangleName();
+                                                        }
+                                                }
+                                                // otherwise just give type numeric name
+                                                if ( varName.empty() ) {
+                                                        varName = std::to_string( nextVarNum++ );
+                                                }
+                                                varNums[ (*i)->name ] = std::make_pair( varName, (int)(*i)->get_kind() );
                                                 for ( std::list< DeclarationWithType* >::iterator assert = (*i)->assertions.begin(); assert != (*i)->assertions.end(); ++assert ) {
                                                         PassVisitor<Mangler> sub_mangler(
+                                                                mangleOverridable, typeMode, mangleGenericParams, nextVarNum, varNums );
+                                                                mangleOverridable, typeMode, mangleGenericParams, nextVarNum, env,
+                                                                varNums );
                                                         (*assert)->accept( sub_mangler );
                                                         assertionNames.push_back( sub_mangler.pass.get_mangleName() );

src/SymTab/Mangler.h

-              r933f32f
+              r6a9d4b4
                 /// Mangle ignoring generic type parameters
                 std::string mangleConcrete( Type* ty );
+                /// Mangle for assertion key
+                std::string mangleAssnKey( DeclarationWithType* decl,
+                        const ResolvExpr::TypeEnvironment& env );
                 namespace Encoding {

src/SymTab/ManglerCommon.cc

-              r933f32f
+              r6a9d4b4
 // Created On       : Sun May 17 21:44:03 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Feb 14 17:06:37 2019
 // Update Count     : 26
+// Last Modified On : Sat Jul 22 09:45:30 2017
+// Update Count     : 15
 //
 …
                         const std::string manglePrefix = "_X";
+                        // GENERATED START, DO NOT EDIT
+                        // GENERATED BY BasicTypes-gen.cc
+                        // NOTES ON MANGLING:
+                        // * Itanium spec says that Float80 encodes to "e" (like LongDouble), but the distinct lengths cause resolution problems.
+                        // * Float128 is supposed to encode to "g", but I wanted it to mangle equal to LongDouble.
+                        // * Mangling for non-standard complex types is by best guess
+                        // * _FloatN is supposed to encode as "DF"N"_"; modified for same reason as above.
+                        // * unused mangling identifiers:
+                        //   - "z" ellipsis
+                        //   - "Dd" IEEE 754r 64-bit decimal floating point (borrowed for _Float32x)
+                        //   - "De" IEEE 754r 128-bit decimal floating point
+                        //   - "Df" IEEE 754r 32-bit decimal floating point
+                        //   - "Dh" IEEE 754r 16-bit decimal floating point (borrowed for _Float16)
+                        //   - "DF"N"_" ISO/IEC TS 18661 N-bit binary floating point (_FloatN)
+                        //   - "Di" char32_t
+                        //   - "Ds" char16_t
+                        const std::string basicTypes[BasicType::NUMBER_OF_BASIC_TYPES] = {
+                                "b",        // _Bool
+                                "c",        // char
+                                "a",        // signed char
+                                "h",        // unsigned char
+                                "s",        // signed short int
+                                "t",        // unsigned short int
+                                "i",        // signed int
+                                "j",        // unsigned int
+                                "l",        // signed long int
+                                "m",        // unsigned long int
+                                "x",        // signed long long int
+                                "y",        // unsigned long long int
+                                "n",        // __int128
+                                "o",        // unsigned __int128
+                                "DF16_",    // _Float16
+                                "CDF16_",   // _Float16 _Complex
+                                "DF32_",    // _Float32
+                                "CDF32_",   // _Float32 _Complex
+                                "f",        // float
+                                "Cf",       // float _Complex
+                                "DF32x_",   // _Float32x
+                                "CDF32x_",  // _Float32x _Complex
+                                "DF64_",    // _Float64
+                                "CDF64_",   // _Float64 _Complex
+                                "d",        // double
+                                "Cd",       // double _Complex
+                                "DF64x_",   // _Float64x
+                                "CDF64x_",  // _Float64x _Complex
+                                "Dq",       // __float80
+                                "DF128_",   // _Float128
+                                "CDF128_",  // _Float128 _Complex
+                                "g",        // __float128
+                                "e",        // long double
+                                "Ce",       // long double _Complex
+                                "DF128x_",  // _Float128x
+                                "CDF128x_", // _Float128x _Complex
+                        }; // basicTypes
+                        // GENERATED END
+                        const std::string basicTypes[] = {
+                                "b",  // Bool
+                                "c",  // Char
+                                "a",  // SignedChar
+                                "h",  // UnsignedChar
+                                "s",  // ShortSignedInt
+                                "t",  // ShortUnsignedInt
+                                "i",  // SignedInt
+                                "j",  // UnsignedInt
+                                "l",  // LongSignedInt
+                                "m",  // LongUnsignedInt
+                                "x",  // LongLongSignedInt
+                                "y",  // LongLongUnsignedInt
+                                "f",  // Float
+                                "d",  // Double
+                                "e",  // LongDouble
+                                "Cf", // FloatComplex
+                                "Cd", // DoubleComplex
+                                "Ce", // LongDoubleComplex
+                                // Note: imaginary is not an overloadable type in C++
+                                "If", // FloatImaginary
+                                "Id", // DoubleImaginary
+                                "Ie", // LongDoubleImaginary
+                                "n",  // SignedInt128
+                                "o",  // UnsignedInt128
+                                "Dq",  // Float80 -- TODO: itanium says Float80 and LongDouble both encode to "e", but doing this causes problems with constructing long double, because the cost tables are incorrect
+                                "g",  // Float128
+                                // "z", // ellipsis
+                                // "Dd" // # IEEE 754r decimal floating point (64 bits)
+                                // "De" // # IEEE 754r decimal floating point (128 bits)
+                                // "Df" // # IEEE 754r decimal floating point (32 bits)
+                                // "Dh" // # IEEE 754r half-precision floating point (16 bits)
+                                // "DF"N_ // # ISO/IEC TS 18661 binary floating point type _FloatN (N bits)
+                                // "Di" // char32_t
+                                // "Ds" // char16_t
+                        };
                         static_assert(
                                 sizeof(basicTypes)/sizeof(basicTypes[0]) == BasicType::NUMBER_OF_BASIC_TYPES,

src/SymTab/Validate.cc

-              r933f32f
+              r6a9d4b4
 #include "CodeGen/OperatorTable.h"     // for isCtorDtor, isCtorDtorAssign
 #include "ControlStruct/Mutate.h"      // for ForExprMutator
-#include "Common/Stats.h"              // for Stats::Heap
 #include "Common/PassVisitor.h"        // for PassVisitor, WithDeclsToAdd
 #include "Common/ScopedMap.h"          // for ScopedMap
 …
                 PassVisitor<FixQualifiedTypes> fixQual;
+                {
+                        Stats::Heap::newPass("validate-A");
+                        Stats::Time::BlockGuard guard("validate-A");
+                        acceptAll( translationUnit, hoistDecls );
+                        ReplaceTypedef::replaceTypedef( translationUnit );
+                        ReturnTypeFixer::fix( translationUnit ); // must happen before autogen
+                        acceptAll( translationUnit, epc ); // must happen before VerifyCtorDtorAssign, because void return objects should not exist; before LinkReferenceToTypes because it is an indexer and needs correct types for mangling
+                }
+                {
+                        Stats::Heap::newPass("validate-B");
+                        Stats::Time::BlockGuard guard("validate-B");
+                        Stats::Time::TimeBlock("Link Reference To Types", [&]() {
+                                acceptAll( translationUnit, lrt ); // must happen before autogen, because sized flag needs to propagate to generated functions
+                        });
+                        Stats::Time::TimeBlock("Fix Qualified Types", [&]() {
+                                mutateAll( translationUnit, fixQual ); // must happen after LinkReferenceToTypes, because aggregate members are accessed
+                        });
+                        Stats::Time::TimeBlock("Hoist Structs", [&]() {
+                                HoistStruct::hoistStruct( translationUnit ); // must happen after EliminateTypedef, so that aggregate typedefs occur in the correct order
+                        });
+                        Stats::Time::TimeBlock("Eliminate Typedefs", [&]() {
+                                EliminateTypedef::eliminateTypedef( 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
+                        VerifyCtorDtorAssign::verify( translationUnit );  // must happen before autogen, because autogen examines existing ctor/dtors
+                        ReturnChecker::checkFunctionReturns( translationUnit );
+                        InitTweak::fixReturnStatements( translationUnit ); // must happen before autogen
+                }
+                {
+                        Stats::Heap::newPass("validate-D");
+                        Stats::Time::BlockGuard guard("validate-D");
+                        Stats::Time::TimeBlock("Apply Concurrent Keywords", [&]() {
+                                Concurrency::applyKeywords( 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
+                        });
+                        Stats::Time::TimeBlock("Hoist Control Declarations", [&]() {
+                                ControlStruct::hoistControlDecls( translationUnit );  // hoist initialization out of for statements; must happen before autogenerateRoutines
+                        });
+                        Stats::Time::TimeBlock("Generate Autogen routines", [&]() {
+                                autogenerateRoutines( translationUnit ); // moved up, used to be below compoundLiteral - currently needs EnumAndPointerDecay
+                        });
+                }
+                {
+                        Stats::Heap::newPass("validate-E");
+                        Stats::Time::BlockGuard guard("validate-E");
+                        Stats::Time::TimeBlock("Implement Mutex Func", [&]() {
+                                Concurrency::implementMutexFuncs( translationUnit );
+                        });
+                        Stats::Time::TimeBlock("Implement Thread Start", [&]() {
+                                Concurrency::implementThreadStarter( translationUnit );
+                        });
+                        Stats::Time::TimeBlock("Compound Literal", [&]() {
+                                mutateAll( translationUnit, compoundliteral );
+                        });
+                        Stats::Time::TimeBlock("Resolve With Expressions", [&]() {
+                                ResolvExpr::resolveWithExprs( translationUnit ); // must happen before FixObjectType because user-code is resolved and may contain with variables
+                        });
+                }
+                {
+                        Stats::Heap::newPass("validate-F");
+                        Stats::Time::BlockGuard guard("validate-F");
+                        Stats::Time::TimeBlock("Fix Object Type", [&]() {
+                                FixObjectType::fix( translationUnit );
+                        });
+                        Stats::Time::TimeBlock("Array Length", [&]() {
+                                ArrayLength::computeLength( translationUnit );
+                        });
+                        Stats::Time::TimeBlock("Find Special Declarations", [&]() {
+                                Validate::findSpecialDecls( translationUnit );
+                        });
+                        Stats::Time::TimeBlock("Fix Label Address", [&]() {
+                                mutateAll( translationUnit, labelAddrFixer );
+                        });
+                        Stats::Time::TimeBlock("Handle Attributes", [&]() {
+                                Validate::handleAttributes( translationUnit );
+                        });
+                }
+                acceptAll( translationUnit, hoistDecls );
+                ReplaceTypedef::replaceTypedef( translationUnit );
+                ReturnTypeFixer::fix( translationUnit ); // must happen before autogen
+                acceptAll( translationUnit, epc ); // must happen before VerifyCtorDtorAssign, because void return objects should not exist; before LinkReferenceToTypes because it is an indexer and needs correct types for mangling
+                acceptAll( translationUnit, lrt ); // must happen before autogen, because sized flag needs to propagate to generated functions
+                mutateAll( translationUnit, fixQual ); // must happen after LinkReferenceToTypes, because aggregate members are accessed
+                HoistStruct::hoistStruct( translationUnit ); // must happen after EliminateTypedef, so that aggregate typedefs occur in the correct order
+                EliminateTypedef::eliminateTypedef( translationUnit ); //
+                acceptAll( translationUnit, genericParams );  // check as early as possible - can't happen before LinkReferenceToTypes
+                VerifyCtorDtorAssign::verify( translationUnit );  // must happen before autogen, because autogen examines existing ctor/dtors
+                ReturnChecker::checkFunctionReturns( translationUnit );
+                InitTweak::fixReturnStatements( translationUnit ); // must happen before autogen
+                Concurrency::applyKeywords( translationUnit );
+                acceptAll( translationUnit, fpd ); // must happen before autogenerateRoutines, after Concurrency::applyKeywords because uniqueIds must be set on declaration before resolution
+                ControlStruct::hoistControlDecls( translationUnit );  // hoist initialization out of for statements; must happen before autogenerateRoutines
+                autogenerateRoutines( translationUnit ); // moved up, used to be below compoundLiteral - currently needs EnumAndPointerDecay
+                Concurrency::implementMutexFuncs( translationUnit );
+                Concurrency::implementThreadStarter( translationUnit );
+                mutateAll( translationUnit, compoundliteral );
+                ResolvExpr::resolveWithExprs( translationUnit ); // must happen before FixObjectType because user-code is resolved and may contain with variables
+                FixObjectType::fix( translationUnit );
+                ArrayLength::computeLength( translationUnit );
+                Validate::findSpecialDecls( translationUnit );
+                mutateAll( translationUnit, labelAddrFixer );
+                Validate::handleAttributes( translationUnit );
+        }

src/SymTab/module.mk

-              r933f32f
+              r6a9d4b4
 ###############################################################################
+SRC_SYMTAB = \
+      SymTab/Autogen.cc \
+      SymTab/FixFunction.cc \
+      SymTab/Indexer.cc \
+      SymTab/Mangler.cc \
+      SymTab/ManglerCommon.cc \
+      SymTab/Validate.cc
+SRC += $(SRC_SYMTAB)
+SRCDEMANGLE += $(SRC_SYMTAB) SymTab/Demangle.cc
+SRC += SymTab/Indexer.cc \
+       SymTab/Mangler.cc \
+       SymTab/ManglerCommon.cc \
+       SymTab/Validate.cc \
+       SymTab/FixFunction.cc \
+       SymTab/Autogen.cc

src/SynTree/AddressExpr.cc

-              r933f32f
+              r6a9d4b4
 // Author           : Richard C. Bilson
 // Created On       : Sun May 17 23:54:44 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Feb 28 13:13:38 2019
 // Update Count     : 10
+// Last Modified By : Rob Schluntz
+// Last Modified On : Tue Apr 26 12:35:13 2016
+// Update Count     : 6
 //
 …
                 } else {
                         // taking address of non-lvalue -- must be a reference, loses one layer of reference
+                        if ( ReferenceType * refType = dynamic_cast< ReferenceType * >( arg->result ) ) {
+                                set_result( addrType( refType->base ) );
+                        } else {
+                                SemanticError( arg->result, "Attempt to take address of non-lvalue expression: " );
+                        } // if
+                        ReferenceType * refType = strict_dynamic_cast< ReferenceType * >( arg->result );
+                        set_result( addrType( refType->base ) );
+                }
                 // result of & is never an lvalue

src/SynTree/Attribute.cc

r933f32f	r6a9d4b4
21	21	#include "Expression.h" // for Expression
22	22
23		Attribute::Attribute( const Attribute &other ) : ~~BaseSyntaxNode( other ),~~ name( other.name ) {
	23	Attribute::Attribute( const Attribute &other ) : name( other.name ) {
24	24	cloneAll( other.parameters, parameters );
25	25	}

src/SynTree/BaseSyntaxNode.h

-              r933f32f
+              r6a9d4b4
 #include "Common/CodeLocation.h"
 #include "Common/Indenter.h"
-#include "Common/Stats.h"
 class Visitor;
 class Mutator;
 …
 class BaseSyntaxNode {
   public:
-  static Stats::Counters::SimpleCounter* new_nodes;
         CodeLocation location;
-  BaseSyntaxNode() { ++*new_nodes; }
-  BaseSyntaxNode( const BaseSyntaxNode& o ) : location(o.location) { ++*new_nodes; }
         virtual ~BaseSyntaxNode() {}

src/SynTree/BasicType.cc

-              r933f32f
+              r6a9d4b4
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Jan 31 21:37:36 2019
 // Update Count     : 12
+// Last Modified On : Mon Sep 25 14:14:03 2017
+// Update Count     : 11
 //
 …
 bool BasicType::isInteger() const {
-        return kind <= UnsignedInt128;
-#if 0
         switch ( kind ) {
           case Bool:
 …
         assert( false );
         return false;
-#endif
+}

src/SynTree/Constant.cc

-              r933f32f
+              r6a9d4b4
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed Feb 13 18:11:22 2019
 // Update Count     : 32
+// Last Modified By : Andrew Beach
+// Last Modified On : Fri Spt 28 14:49:00 2018
+// Update Count     : 30
 //
 …
 Constant::Constant( Type * type, std::string rep, double val ) : type( type ), rep( rep ), val( val ) {}
 Constant::Constant( const Constant &other ) : BaseSyntaxNode( other ), rep( other.rep ), val( other.val ) {
+Constant::Constant( const Constant &other ) : rep( other.rep ), val( other.val ) {
         type = other.type->clone();
+}

src/SynTree/Declaration.cc

r933f32f	r6a9d4b4
31	31
32	32	Declaration::Declaration( const std::string &name, Type::StorageClasses scs, LinkageSpec::Spec linkage )
33		: name( name ), linkage( linkage ), ~~uniqueId( 0 ), storageClasses( scs~~ ) {
	33	: name( name ), linkage( linkage ), storageClasses( scs ), uniqueId( 0 ) {
34	34	}
35	35
36	36	Declaration::Declaration( const Declaration &other )
37		: BaseSyntaxNode( other ), name( other.name ), linkage( other.linkage ), extension( other.extension ), ~~uniqueId( other.uniqueId ), storageClasses( other.storageClasses~~ ) {
	37	: BaseSyntaxNode( other ), name( other.name ), linkage( other.linkage ), extension( other.extension ), storageClasses( other.storageClasses ), uniqueId( other.uniqueId ) {
38	38	}
39	39

src/SynTree/Declaration.h

-              r933f32f
+              r6a9d4b4
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Andrew Beach
 // Last Modified On : Thr May  2 10:47:00 2019
 // Update Count     : 135
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Sun Sep  3 19:24:06 2017
+// Update Count     : 131
 //
 …
 #include <iosfwd>                // for ostream
 #include <list>                  // for list
-#include <unordered_map>         // for unordered_map
 #include <string>                // for string, operator+, allocator, to_string
 …
         static Declaration *declFromId( UniqueId id );
+  private:
+        Type::StorageClasses storageClasses;
         UniqueId uniqueId;
-        Type::StorageClasses storageClasses;
-  private:
 };
 …
         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 );
 …
                 TypeDecl::Kind kind;
                 bool 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);}
 …
         virtual void print( std::ostream &os, Indenter indent = {} ) const override;
+  private:
         Kind kind;
 };
 …
         virtual void accept( Visitor &v ) override { v.visit( this ); }
         virtual Declaration *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
+  private:
         DeclarationNode::Aggregate kind;
-  private:
         virtual std::string typeString() const override;
 };
 …
         virtual Declaration *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
   private:
         std::unordered_map< std::string, long long int > enumValues;
+        std::map< std::string, long long int > enumValues;
         virtual std::string typeString() const override;
 };

src/SynTree/Expression.cc

-              r933f32f
+              r6a9d4b4
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Tue Feb 19 18:10:55 2019
 // Update Count     : 60
+// Last Modified On : Tue Jul 25 14:15:47 2017
+// Update Count     : 54
 //
 …
 #include "GenPoly/Lvalue.h"
 void printInferParams( const InferredParams & inferParams, std::ostream & os, Indenter indent, int level ) {
+void printInferParams( const InferredParams & inferParams, std::ostream &os, Indenter indent, int level ) {
         if ( ! inferParams.empty() ) {
                 os << indent << "with inferred parameters " << level << ":" << std::endl;
 …
 Expression::Expression() : result( 0 ), env( 0 ) {}
 Expression::Expression( const Expression & other ) : BaseSyntaxNode( other ), result( maybeClone( other.result ) ), env( maybeClone( other.env ) ), extension( other.extension ), inferParams( other.inferParams ), resnSlots( other.resnSlots ) {}
+Expression::Expression( const Expression &other ) : BaseSyntaxNode( other ), result( maybeClone( other.result ) ), env( maybeClone( other.env ) ), extension( other.extension ), inferParams( other.inferParams ), resnSlots( other.resnSlots ) {}
 void Expression::spliceInferParams( Expression * other ) {
 …
+}
 void Expression::print( std::ostream & os, Indenter indent ) const {
+void Expression::print( std::ostream &os, Indenter indent ) const {
         printInferParams( inferParams, os, indent+1, 0 );
 …
+}
 ConstantExpr::ConstantExpr( const ConstantExpr & other) : Expression( other ), constant( other.constant ) {
+ConstantExpr::ConstantExpr( const ConstantExpr &other) : Expression( other ), constant( other.constant ) {
+}
 ConstantExpr::~ConstantExpr() {}
 void ConstantExpr::print( std::ostream & os, Indenter indent ) const {
+void ConstantExpr::print( std::ostream &os, Indenter indent ) const {
         os << "constant expression " ;
         constant.print( os );
 …
+}
 VariableExpr::VariableExpr( const VariableExpr & other ) : Expression( other ), var( other.var ) {
+VariableExpr::VariableExpr( const VariableExpr &other ) : Expression( other ), var( other.var ) {
+}
 …
+}
 void VariableExpr::print( std::ostream & os, Indenter indent ) const {
+void VariableExpr::print( std::ostream &os, Indenter indent ) const {
         os << "Variable Expression: ";
         var->printShort(os, indent);
 …
+}
 SizeofExpr::SizeofExpr( Expression * expr_ ) :
+SizeofExpr::SizeofExpr( Expression *expr_ ) :
                 Expression(), expr(expr_), type(0), isType(false) {
         set_result( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ) );
+}
 SizeofExpr::SizeofExpr( Type * type_ ) :
+SizeofExpr::SizeofExpr( Type *type_ ) :
                 Expression(), expr(0), type(type_), isType(true) {
         set_result( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ) );
+}
 SizeofExpr::SizeofExpr( const SizeofExpr & other ) :
+SizeofExpr::SizeofExpr( const SizeofExpr &other ) :
         Expression( other ), expr( maybeClone( other.expr ) ), type( maybeClone( other.type ) ), isType( other.isType ) {
+}
 …
+}
 void SizeofExpr::print( std::ostream & os, Indenter indent) const {
+void SizeofExpr::print( std::ostream &os, Indenter indent) const {
         os << "Sizeof Expression on: ";
         if (isType) type->print(os, indent+1);
 …
+}
 AlignofExpr::AlignofExpr( Expression * expr_ ) :
+AlignofExpr::AlignofExpr( Expression *expr_ ) :
                 Expression(), expr(expr_), type(0), isType(false) {
         set_result( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ) );
+}
 AlignofExpr::AlignofExpr( Type * type_ ) :
+AlignofExpr::AlignofExpr( Type *type_ ) :
                 Expression(), expr(0), type(type_), isType(true) {
         set_result( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ) );
+}
 AlignofExpr::AlignofExpr( const AlignofExpr & other ) :
+AlignofExpr::AlignofExpr( const AlignofExpr &other ) :
         Expression( other ), expr( maybeClone( other.expr ) ), type( maybeClone( other.type ) ), isType( other.isType ) {
+}
 …
+}
 void AlignofExpr::print( std::ostream & os, Indenter indent) const {
+void AlignofExpr::print( std::ostream &os, Indenter indent) const {
         os << "Alignof Expression on: ";
         if (isType) type->print(os, indent+1);
 …
+}
 UntypedOffsetofExpr::UntypedOffsetofExpr( Type * type, const std::string & member ) :
+UntypedOffsetofExpr::UntypedOffsetofExpr( Type *type, const std::string &member ) :
                 Expression(), type(type), member(member) {
         assert( type );
 …
+}
 UntypedOffsetofExpr::UntypedOffsetofExpr( const UntypedOffsetofExpr & other ) :
+UntypedOffsetofExpr::UntypedOffsetofExpr( const UntypedOffsetofExpr &other ) :
         Expression( other ), type( maybeClone( other.type ) ), member( other.member ) {}
 …
+}
 void UntypedOffsetofExpr::print( std::ostream & os, Indenter indent) const {
+void UntypedOffsetofExpr::print( std::ostream &os, Indenter indent) const {
         os << "Untyped Offsetof Expression on member " << member << " of ";
         type->print(os, indent+1);
 …
+}
 OffsetofExpr::OffsetofExpr( Type * type, DeclarationWithType * member ) :
+OffsetofExpr::OffsetofExpr( Type *type, DeclarationWithType *member ) :
                 Expression(), type(type), member(member) {
         assert( member );
 …
+}
 OffsetofExpr::OffsetofExpr( const OffsetofExpr & other ) :
+OffsetofExpr::OffsetofExpr( const OffsetofExpr &other ) :
         Expression( other ), type( maybeClone( other.type ) ), member( other.member ) {}
 …
+}
 void OffsetofExpr::print( std::ostream & os, Indenter indent) const {
+void OffsetofExpr::print( std::ostream &os, Indenter indent) const {
         os << "Offsetof Expression on member " << member->name << " of ";
         type->print(os, indent+1);
 …
+}
 OffsetPackExpr::OffsetPackExpr( StructInstType * type ) : Expression(), type( type ) {
+OffsetPackExpr::OffsetPackExpr( StructInstType *type ) : Expression(), type( type ) {
         assert( type );
         set_result( new ArrayType( Type::Qualifiers(), new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ), 0, false, false ) );
+}
 OffsetPackExpr::OffsetPackExpr( const OffsetPackExpr & other ) : Expression( other ), type( maybeClone( other.type ) ) {}
+OffsetPackExpr::OffsetPackExpr( const OffsetPackExpr &other ) : Expression( other ), type( maybeClone( other.type ) ) {}
 OffsetPackExpr::~OffsetPackExpr() { delete type; }
 void OffsetPackExpr::print( std::ostream & os, Indenter indent ) const {
+void OffsetPackExpr::print( std::ostream &os, Indenter indent ) const {
         os << "Offset pack expression on ";
         type->print(os, indent+1);
 …
+}
 AttrExpr::AttrExpr( Expression * attr, Expression * expr_ ) :
+AttrExpr::AttrExpr( Expression *attr, Expression *expr_ ) :
                 Expression(), attr( attr ), expr(expr_), type(0), isType(false) {
+}
 AttrExpr::AttrExpr( Expression * attr, Type * type_ ) :
+AttrExpr::AttrExpr( Expression *attr, Type *type_ ) :
                 Expression(), attr( attr ), expr(0), type(type_), isType(true) {
+}
 AttrExpr::AttrExpr( const AttrExpr & other ) :
+AttrExpr::AttrExpr( const AttrExpr &other ) :
                 Expression( other ), attr( maybeClone( other.attr ) ), expr( maybeClone( other.expr ) ), type( maybeClone( other.type ) ), isType( other.isType ) {
+}
 …
+}
 void AttrExpr::print( std::ostream & os, Indenter indent) const {
+void AttrExpr::print( std::ostream &os, Indenter indent) const {
         os << "Attr ";
         attr->print( os, indent+1);
 …
+}
 CastExpr::CastExpr( Expression * arg, Type * toType, bool isGenerated ) : arg(arg), isGenerated( isGenerated ) {
+CastExpr::CastExpr( Expression *arg, Type *toType, bool isGenerated ) : Expression(), arg(arg), isGenerated( isGenerated ) {
         set_result(toType);
+}
 CastExpr::CastExpr( Expression * arg, bool isGenerated ) : arg(arg), isGenerated( isGenerated ) {
+CastExpr::CastExpr( Expression *arg, bool isGenerated ) : Expression(), arg(arg), isGenerated( isGenerated ) {
         set_result( new VoidType( Type::Qualifiers() ) );
+}
 CastExpr::CastExpr( const CastExpr & other ) : Expression( other ), arg( maybeClone( other.arg ) ), isGenerated( other.isGenerated ) {
+CastExpr::CastExpr( const CastExpr &other ) : Expression( other ), arg( maybeClone( other.arg ) ), isGenerated( other.isGenerated ) {
+}
 …
+}
 void CastExpr::print( std::ostream & os, Indenter indent ) const {
         os << (isGenerated ? "Generated " : "Explicit ") << "Cast of:" << std::endl << indent+1;
+void CastExpr::print( std::ostream &os, Indenter indent ) const {
+        os << "Cast of:" << std::endl << indent+1;
         arg->print(os, indent+1);
         os << std::endl << indent << "... to:";
 …
+}
 KeywordCastExpr::KeywordCastExpr( Expression * arg, Target target ) : Expression(), arg(arg), target( target ) {
+}
 KeywordCastExpr::KeywordCastExpr( const KeywordCastExpr & other ) : Expression( other ), arg( maybeClone( other.arg ) ), target( other.target ) {
+KeywordCastExpr::KeywordCastExpr( Expression *arg, Target target ) : Expression(), arg(arg), target( target ) {
+}
+KeywordCastExpr::KeywordCastExpr( const KeywordCastExpr &other ) : Expression( other ), arg( maybeClone( other.arg ) ), target( other.target ) {
+}
 …
+}
 void KeywordCastExpr::print( std::ostream & os, Indenter indent ) const {
+void KeywordCastExpr::print( std::ostream &os, Indenter indent ) const {
         os << "Keyword Cast of:" << std::endl << indent+1;
         arg->print(os, indent+1);
 …
+}
 VirtualCastExpr::VirtualCastExpr( Expression * arg_, Type * toType ) : Expression(), arg(arg_) {
+VirtualCastExpr::VirtualCastExpr( Expression *arg_, Type *toType ) : Expression(), arg(arg_) {
         set_result(toType);
+}
 VirtualCastExpr::VirtualCastExpr( const VirtualCastExpr & other ) : Expression( other ), arg( maybeClone( other.arg ) ) {
+VirtualCastExpr::VirtualCastExpr( const VirtualCastExpr &other ) : Expression( other ), arg( maybeClone( other.arg ) ) {
+}
 …
+}
 void VirtualCastExpr::print( std::ostream & os, Indenter indent ) const {
+void VirtualCastExpr::print( std::ostream &os, Indenter indent ) const {
         os << "Virtual Cast of:" << std::endl << indent+1;
         arg->print(os, indent+1);
 …
+}
 UntypedMemberExpr::UntypedMemberExpr( Expression * member, Expression * aggregate ) :
+UntypedMemberExpr::UntypedMemberExpr( Expression * member, Expression *aggregate ) :
                 Expression(), member(member), aggregate(aggregate) {
         assert( aggregate );
+}
 UntypedMemberExpr::UntypedMemberExpr( const UntypedMemberExpr & other ) :
+UntypedMemberExpr::UntypedMemberExpr( const UntypedMemberExpr &other ) :
                 Expression( other ), member( maybeClone( other.member ) ), aggregate( maybeClone( other.aggregate ) ) {
+}
 …
+}
 void UntypedMemberExpr::print( std::ostream & os, Indenter indent ) const {
+void UntypedMemberExpr::print( std::ostream &os, Indenter indent ) const {
         os << "Untyped Member Expression, with field: " << std::endl << indent+1;
         member->print(os, indent+1 );
 …
+}
 MemberExpr::MemberExpr( DeclarationWithType * member, Expression * aggregate ) :
+MemberExpr::MemberExpr( DeclarationWithType *member, Expression *aggregate ) :
                 Expression(), member(member), aggregate(aggregate) {
         assert( member );
 …
+}
 MemberExpr::MemberExpr( const MemberExpr & other ) :
+MemberExpr::MemberExpr( const MemberExpr &other ) :
                 Expression( other ), member( other.member ), aggregate( maybeClone( other.aggregate ) ) {
+}
 …
+}
 void MemberExpr::print( std::ostream & os, Indenter indent ) const {
+void MemberExpr::print( std::ostream &os, Indenter indent ) const {
         os << "Member Expression, with field:" << std::endl;
         os << indent+1;
 …
+}
 UntypedExpr::UntypedExpr( Expression * function, const std::list<Expression *> & args ) :
+UntypedExpr::UntypedExpr( Expression *function, const std::list<Expression *> &args ) :
                 Expression(), function(function), args(args) {}
 UntypedExpr::UntypedExpr( const UntypedExpr & other ) :
+UntypedExpr::UntypedExpr( const UntypedExpr &other ) :
                 Expression( other ), function( maybeClone( other.function ) ) {
         cloneAll( other.args, args );
 …
 void UntypedExpr::print( std::ostream & os, Indenter indent ) const {
+void UntypedExpr::print( std::ostream &os, Indenter indent ) const {
         os << "Applying untyped:" << std::endl;
         os << indent+1;
 …
+}
 NameExpr::NameExpr( const NameExpr & other ) : Expression( other ), name( other.name ) {
+NameExpr::NameExpr( const NameExpr &other ) : Expression( other ), name( other.name ) {
+}
 NameExpr::~NameExpr() {}
 void NameExpr::print( std::ostream & os, Indenter indent ) const {
+void NameExpr::print( std::ostream &os, Indenter indent ) const {
         os << "Name: " << get_name();
         Expression::print( os, indent );
+}
 LogicalExpr::LogicalExpr( Expression * arg1_, Expression * arg2_, bool andp ) :
+LogicalExpr::LogicalExpr( Expression *arg1_, Expression *arg2_, bool andp ) :
                 Expression(), arg1(arg1_), arg2(arg2_), isAnd(andp) {
         set_result( new BasicType( Type::Qualifiers(), BasicType::SignedInt ) );
+}
 LogicalExpr::LogicalExpr( const LogicalExpr & other ) :
+LogicalExpr::LogicalExpr( const LogicalExpr &other ) :
                 Expression( other ), arg1( maybeClone( other.arg1 ) ), arg2( maybeClone( other.arg2 ) ), isAnd( other.isAnd ) {
+}
 …
+}
 void LogicalExpr::print( std::ostream & os, Indenter indent )const {
+void LogicalExpr::print( std::ostream &os, Indenter indent )const {
         os << "Short-circuited operation (" << (isAnd ? "and" : "or") << ") on: ";
         arg1->print(os);
 …
                 Expression(), arg1(arg1), arg2(arg2), arg3(arg3) {}
 ConditionalExpr::ConditionalExpr( const ConditionalExpr & other ) :
+ConditionalExpr::ConditionalExpr( const ConditionalExpr &other ) :
                 Expression( other ), arg1( maybeClone( other.arg1 ) ), arg2( maybeClone( other.arg2 ) ), arg3( maybeClone( other.arg3 ) ) {
+}
 …
+}
 void ConditionalExpr::print( std::ostream & os, Indenter indent ) const {
+void ConditionalExpr::print( std::ostream &os, Indenter indent ) const {
         os << "Conditional expression on: " << std::endl << indent+1;
         arg1->print( os, indent+1 );
 …
 void AsmExpr::print( std::ostream & os, Indenter indent ) const {
+void AsmExpr::print( std::ostream &os, Indenter indent ) const {
         os << "Asm Expression: " << std::endl;
         if ( inout ) inout->print( os, indent+1 );
 …
+}
 void ImplicitCopyCtorExpr::print( std::ostream & os, Indenter indent ) const {
+void ImplicitCopyCtorExpr::print( std::ostream &os, Indenter indent ) const {
         os <<  "Implicit Copy Constructor Expression: " << std::endl << indent+1;
         callExpr->print( os, indent+1 );
 …
+}
 void ConstructorExpr::print( std::ostream & os, Indenter indent ) const {
+void ConstructorExpr::print( std::ostream &os, Indenter indent ) const {
         os <<  "Constructor Expression: " << std::endl << indent+1;
         callExpr->print( os, indent + 2 );
 …
+}
 CompoundLiteralExpr::CompoundLiteralExpr( const CompoundLiteralExpr & other ) : Expression( other ), initializer( other.initializer->clone() ) {}
+CompoundLiteralExpr::CompoundLiteralExpr( const CompoundLiteralExpr &other ) : Expression( other ), initializer( other.initializer->clone() ) {}
 CompoundLiteralExpr::~CompoundLiteralExpr() {
 …
+}
 void CompoundLiteralExpr::print( std::ostream & os, Indenter indent ) const {
+void CompoundLiteralExpr::print( std::ostream &os, Indenter indent ) const {
         os << "Compound Literal Expression: " << std::endl << indent+1;
         result->print( os, indent+1 );
 …
+}
 RangeExpr::RangeExpr( Expression * low, Expression * high ) : low( low ), high( high ) {}
 RangeExpr::RangeExpr( const RangeExpr & other ) : Expression( other ), low( other.low->clone() ), high( other.high->clone() ) {}
 void RangeExpr::print( std::ostream & os, Indenter indent ) const {
+RangeExpr::RangeExpr( Expression *low, Expression *high ) : low( low ), high( high ) {}
+RangeExpr::RangeExpr( const RangeExpr &other ) : Expression( other ), low( other.low->clone() ), high( other.high->clone() ) {}
+void RangeExpr::print( std::ostream &os, Indenter indent ) const {
         os << "Range Expression: ";
         low->print( os, indent );
 …
+}
 StmtExpr::StmtExpr( CompoundStmt * statements ) : statements( statements ) {
+StmtExpr::StmtExpr( CompoundStmt *statements ) : statements( statements ) {
         computeResult();
+}
 StmtExpr::StmtExpr( const StmtExpr & other ) : Expression( other ), statements( other.statements->clone() ) {
+StmtExpr::StmtExpr( const StmtExpr &other ) : Expression( other ), statements( other.statements->clone() ) {
         cloneAll( other.returnDecls, returnDecls );
         cloneAll( other.dtors, dtors );
 …
+        }
+}
 void StmtExpr::print( std::ostream & os, Indenter indent ) const {
+void StmtExpr::print( std::ostream &os, Indenter indent ) const {
         os << "Statement Expression: " << std::endl << indent+1;
         statements->print( os, indent+1 );
 …
 long long UniqueExpr::count = 0;
 UniqueExpr::UniqueExpr( Expression * expr, long long idVal ) : expr( expr ), object( nullptr ), var( nullptr ), id( idVal ) {
+UniqueExpr::UniqueExpr( Expression *expr, long long idVal ) : expr( expr ), object( nullptr ), var( nullptr ), id( idVal ) {
         assert( expr );
         assert( count != -1 );
 …
+        }
+}
 UniqueExpr::UniqueExpr( const UniqueExpr & other ) : Expression( other ), expr( maybeClone( other.expr ) ), object( maybeClone( other.object ) ), var( maybeClone( other.var ) ), id( other.id ) {
+UniqueExpr::UniqueExpr( const UniqueExpr &other ) : Expression( other ), expr( maybeClone( other.expr ) ), object( maybeClone( other.object ) ), var( maybeClone( other.var ) ), id( other.id ) {
+}
 UniqueExpr::~UniqueExpr() {
 …
         delete var;
+}
 void UniqueExpr::print( std::ostream & os, Indenter indent ) const {
+void UniqueExpr::print( std::ostream &os, Indenter indent ) const {
         os << "Unique Expression with id:" << id << std::endl << indent+1;
         expr->print( os, indent+1 );

src/SynTree/Expression.h

-              r933f32f
+              r6a9d4b4
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Mon Feb 18 18:29:51 2019
 // Update Count     : 49
+// Last Modified On : Sun Sep  3 19:23:46 2017
+// Update Count     : 48
 //
 …
   public:
         Expression * arg;
         bool isGenerated = true; // cast generated implicitly by code generation or explicit in program
+        bool isGenerated = true; // whether this cast appeared in the source program
         CastExpr( Expression * arg, bool isGenerated = true );

src/SynTree/Label.h

r933f32f	r6a9d4b4
35	35	operator std::string() const { return name; }
36	36	bool empty() { return name.empty(); }
37
	37	private:
38	38	std::string name;
39	39	Statement * labelled;

src/SynTree/Mutator.h

r933f32f	r6a9d4b4
121	121	virtual Initializer * mutate( ConstructorInit * ctorInit ) = 0 ;
122	122
	123	virtual Subrange * mutate( Subrange * subrange ) = 0;
	124
123	125	virtual Constant * mutate( Constant * constant ) = 0;
124	126

src/SynTree/Statement.h

-              r933f32f
+              r6a9d4b4
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Tue Mar 12 09:01:53 2019
 // Update Count     : 83
+// Last Modified On : Thu Mar  8 14:53:02 2018
+// Update Count     : 78
 //
 …
 #include <list>                    // for list
 #include <memory>                  // for allocator
 #include <vector>                                  // for vector
+#include <vector>                        // for vector
 #include "BaseSyntaxNode.h"        // for BaseSyntaxNode
 …
         const std::list<Label> & get_labels() const { return labels; }
         virtual Statement * clone() const override = 0;
         virtual void accept( Visitor & v ) override = 0;
         virtual Statement * acceptMutator( Mutator & m ) override = 0;
         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
+        virtual Statement *clone() const override = 0;
+        virtual void accept( Visitor &v ) override = 0;
+        virtual Statement *acceptMutator( Mutator &m ) override = 0;
+        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
 };
 …
         CompoundStmt();
         CompoundStmt( std::list<Statement *> stmts );
         CompoundStmt( const CompoundStmt & other );
+        CompoundStmt( const CompoundStmt &other );
         virtual ~CompoundStmt();
 …
         void push_front( Statement * stmt ) { kids.push_front( stmt ); }
         virtual CompoundStmt * clone() const override { return new CompoundStmt( *this ); }
         virtual void accept( Visitor & v ) override { v.visit( this ); }
         virtual CompoundStmt * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
+        virtual CompoundStmt *clone() const override { return new CompoundStmt( *this ); }
+        virtual void accept( Visitor &v ) override { v.visit( this ); }
+        virtual CompoundStmt *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
+        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
 };
 …
         NullStmt( const std::list<Label> & labels = {} );
         virtual NullStmt * clone() const override { return new NullStmt( *this ); }
         virtual void accept( Visitor & v ) override { v.visit( this ); }
         virtual NullStmt * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
+        virtual NullStmt *clone() const override { return new NullStmt( *this ); }
+        virtual void accept( Visitor &v ) override { v.visit( this ); }
+        virtual NullStmt *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
+        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
 };
 class ExprStmt : public Statement {
   public:
         Expression * expr;
         ExprStmt( Expression * expr );
         ExprStmt( const ExprStmt & other );
+        Expression *expr;
+        ExprStmt( Expression *expr );
+        ExprStmt( const ExprStmt &other );
         virtual ~ExprStmt();
         Expression * get_expr() { return expr; }
         void set_expr( Expression * newValue ) { expr = newValue; }
         virtual ExprStmt * clone() const override { return new ExprStmt( *this ); }
         virtual void accept( Visitor & v ) override { v.visit( this ); }
         virtual Statement * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
+        Expression *get_expr() { return expr; }
+        void set_expr( Expression *newValue ) { expr = newValue; }
+        virtual ExprStmt *clone() const override { return new ExprStmt( *this ); }
+        virtual void accept( Visitor &v ) override { v.visit( this ); }
+        virtual Statement *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
+        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
 };
 …
   public:
         bool voltile;
         Expression * instruction;
+        Expression *instruction;
         std::list<Expression *> output, input;
         std::list<ConstantExpr *> clobber;
         std::list<Label> gotolabels;
         AsmStmt( bool voltile, Expression * instruction, std::list<Expression *> output, std::list<Expression *> input, std::list<ConstantExpr *> clobber, std::list<Label> gotolabels );
         AsmStmt( const AsmStmt & other );
+        AsmStmt( bool voltile, Expression *instruction, std::list<Expression *> output, std::list<Expression *> input, std::list<ConstantExpr *> clobber, std::list<Label> gotolabels );
+        AsmStmt( const AsmStmt &other );
         virtual ~AsmStmt();
 …
         void set_output( const std::list<Expression *> & newValue ) { output = newValue; }
         std::list<Expression *> & get_input() { return input; }
         void set_input( const std::list<Expression *> & newValue ) { input = newValue; }
+        void set_input( const std::list<Expression *> &newValue ) { input = newValue; }
         std::list<ConstantExpr *> & get_clobber() { return clobber; }
         void set_clobber( const std::list<ConstantExpr *> & newValue ) { clobber = newValue; }
+        void set_clobber( const std::list<ConstantExpr *> &newValue ) { clobber = newValue; }
         std::list<Label> & get_gotolabels() { return gotolabels; }
         void set_gotolabels( const std::list<Label> & newValue ) { gotolabels = newValue; }
+        void set_gotolabels( const std::list<Label> &newValue ) { gotolabels = newValue; }
         virtual AsmStmt * clone() const { return new AsmStmt( *this ); }
 …
 class IfStmt : public Statement {
   public:
         Expression * condition;
         Statement * thenPart;
         Statement * elsePart;
+        Expression *condition;
+        Statement *thenPart;
+        Statement *elsePart;
         std::list<Statement *> initialization;
         IfStmt( Expression * condition, Statement * thenPart, Statement * elsePart,
+        IfStmt( Expression *condition, Statement *thenPart, Statement *elsePart,
                         std::list<Statement *> initialization = std::list<Statement *>() );
         IfStmt( const IfStmt & other );
+        IfStmt( const IfStmt &other );
         virtual ~IfStmt();
         std::list<Statement *> & get_initialization() { return initialization; }
         Expression * get_condition() { return condition; }
         void set_condition( Expression * newValue ) { condition = newValue; }
         Statement * get_thenPart() { return thenPart; }
         void set_thenPart( Statement * newValue ) { thenPart = newValue; }
         Statement * get_elsePart() { return elsePart; }
         void set_elsePart( Statement * newValue ) { elsePart = newValue; }
         virtual IfStmt * clone() const override { return new IfStmt( *this ); }
         virtual void accept( Visitor & v ) override { v.visit( this ); }
         virtual Statement * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
+        std::list<Statement *> &get_initialization() { return initialization; }
+        Expression *get_condition() { return condition; }
+        void set_condition( Expression *newValue ) { condition = newValue; }
+        Statement *get_thenPart() { return thenPart; }
+        void set_thenPart( Statement *newValue ) { thenPart = newValue; }
+        Statement *get_elsePart() { return elsePart; }
+        void set_elsePart( Statement *newValue ) { elsePart = newValue; }
+        virtual IfStmt *clone() const override { return new IfStmt( *this ); }
+        virtual void accept( Visitor &v ) override { v.visit( this ); }
+        virtual Statement *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
+        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
 };
 …
         std::list<Statement *> statements;
         SwitchStmt( Expression * condition, const std::list<Statement *> & statements );
         SwitchStmt( const SwitchStmt & other );
+        SwitchStmt( Expression *condition, const std::list<Statement *> &statements );
+        SwitchStmt( const SwitchStmt &other );
         virtual ~SwitchStmt();
         Expression * get_condition() { return condition; }
         void set_condition( Expression * newValue ) { condition = newValue; }
+        Expression *get_condition() { return condition; }
+        void set_condition( Expression *newValue ) { condition = newValue; }
         std::list<Statement *> & get_statements() { return statements; }
         virtual void accept( Visitor & v ) override { v.visit( this ); }
         virtual Statement * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
         virtual SwitchStmt * clone() const override { return new SwitchStmt( *this ); }
         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
+        virtual void accept( Visitor &v ) override { v.visit( this ); }
+        virtual Statement *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
+        virtual SwitchStmt *clone() const override { return new SwitchStmt( *this ); }
+        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
 };
 …
         std::list<Statement *> stmts;
         CaseStmt( Expression * conditions, const std::list<Statement *> & stmts, bool isdef = false ) throw (SemanticErrorException);
         CaseStmt( const CaseStmt & other );
+        CaseStmt( Expression *conditions, const std::list<Statement *> &stmts, bool isdef = false ) throw (SemanticErrorException);
+        CaseStmt( const CaseStmt &other );
         virtual ~CaseStmt();
 …
         void set_default(bool b) { _isDefault = b; }
         Expression * & get_condition() { return condition; }
         void set_condition( Expression * newValue ) { condition = newValue; }
         std::list<Statement *> & get_statements() { return stmts; }
         void set_statements( std::list<Statement *> & newValue ) { stmts = newValue; }
         virtual void accept( Visitor & v ) override { v.visit( this ); }
         virtual Statement * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
         virtual CaseStmt * clone() const override { return new CaseStmt( *this ); }
         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
+        Expression * &get_condition() { return condition; }
+        void set_condition( Expression *newValue ) { condition = newValue; }
+        std::list<Statement *> &get_statements() { return stmts; }
+        void set_statements( std::list<Statement *> &newValue ) { stmts = newValue; }
+        virtual void accept( Visitor &v ) override { v.visit( this ); }
+        virtual Statement *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
+        virtual CaseStmt *clone() const override { return new CaseStmt( *this ); }
+        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
   private:
         bool _isDefault;
 …
 class WhileStmt : public Statement {
   public:
         Expression * condition;
         Statement * body;
+        Expression *condition;
+        Statement *body;
         std::list<Statement *> initialization;
         bool isDoWhile;
+        WhileStmt( Expression * condition, Statement * body, std::list<Statement *> & initialization, bool isDoWhile = false );
+        WhileStmt( const WhileStmt & other );
+        WhileStmt( Expression *condition,
+               Statement *body, std::list<Statement *> & initialization, bool isDoWhile = false );
+        WhileStmt( const WhileStmt &other );
         virtual ~WhileStmt();
         Expression * get_condition() { return condition; }
         void set_condition( Expression * newValue ) { condition = newValue; }
         Statement * get_body() { return body; }
         void set_body( Statement * newValue ) { body = newValue; }
+        Expression *get_condition() { return condition; }
+        void set_condition( Expression *newValue ) { condition = newValue; }
+        Statement *get_body() { return body; }
+        void set_body( Statement *newValue ) { body = newValue; }
         bool get_isDoWhile() { return isDoWhile; }
         void set_isDoWhile( bool newValue ) { isDoWhile = newValue; }
         virtual WhileStmt * clone() const override { return new WhileStmt( *this ); }
         virtual void accept( Visitor & v ) override { v.visit( this ); }
         virtual Statement * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
+        virtual WhileStmt *clone() const override { return new WhileStmt( *this ); }
+        virtual void accept( Visitor &v ) override { v.visit( this ); }
+        virtual Statement *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
+        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
 };
 …
   public:
         std::list<Statement *> initialization;
+        Expression * condition;
+        Expression * increment;
+        Statement * body;
+        ForStmt( std::list<Statement *> initialization, Expression * condition = 0, Expression * increment = 0, Statement * body = 0 );
+        ForStmt( const ForStmt & other );
+        Expression *condition;
+        Expression *increment;
+        Statement *body;
+        ForStmt( std::list<Statement *> initialization,
+             Expression *condition = 0, Expression *increment = 0, Statement *body = 0 );
+        ForStmt( const ForStmt &other );
         virtual ~ForStmt();
         std::list<Statement *> & get_initialization() { return initialization; }
         Expression * get_condition() { return condition; }
         void set_condition( Expression * newValue ) { condition = newValue; }
         Expression * get_increment() { return increment; }
         void set_increment( Expression * newValue ) { increment = newValue; }
         Statement * get_body() { return body; }
         void set_body( Statement * newValue ) { body = newValue; }
         virtual ForStmt * clone() const override { return new ForStmt( *this ); }
         virtual void accept( Visitor & v ) override { v.visit( this ); }
         virtual Statement * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
+        std::list<Statement *> &get_initialization() { return initialization; }
+        Expression *get_condition() { return condition; }
+        void set_condition( Expression *newValue ) { condition = newValue; }
+        Expression *get_increment() { return increment; }
+        void set_increment( Expression *newValue ) { increment = newValue; }
+        Statement *get_body() { return body; }
+        void set_body( Statement *newValue ) { body = newValue; }
+        virtual ForStmt *clone() const override { return new ForStmt( *this ); }
+        virtual void accept( Visitor &v ) override { v.visit( this ); }
+        virtual Statement *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
+        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
 };
 …
         const Label originalTarget;
         Label target;
         Expression * computedTarget;
+        Expression *computedTarget;
         Type type;
         BranchStmt( Label target, Type ) throw (SemanticErrorException);
         BranchStmt( Expression * computedTarget, Type ) throw (SemanticErrorException);
+        BranchStmt( Expression *computedTarget, Type ) throw (SemanticErrorException);
         Label get_originalTarget() { return originalTarget; }
 …
         void set_target( Label newValue ) { target = newValue; }
         Expression * get_computedTarget() { return computedTarget; }
+        Expression *get_computedTarget() { return computedTarget; }
         void set_target( Expression * newValue ) { computedTarget = newValue; }
         Type get_type() { return type; }
         const char * get_typename() { return brType[ type ]; }
         virtual BranchStmt * clone() const override { return new BranchStmt( *this ); }
         virtual void accept( Visitor & v ) override { v.visit( this ); }
         virtual Statement * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
+        const char *get_typename() { return brType[ type ]; }
+        virtual BranchStmt *clone() const override { return new BranchStmt( *this ); }
+        virtual void accept( Visitor &v ) override { v.visit( this ); }
+        virtual Statement *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
+        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
   private:
         static const char * brType[];
+        static const char *brType[];
 };
 class ReturnStmt : public Statement {
   public:
         Expression * expr;
         ReturnStmt( Expression * expr );
         ReturnStmt( const ReturnStmt & other );
+        Expression *expr;
+        ReturnStmt( Expression *expr );
+        ReturnStmt( const ReturnStmt &other );
         virtual ~ReturnStmt();
         Expression * get_expr() { return expr; }
         void set_expr( Expression * newValue ) { expr = newValue; }
         virtual ReturnStmt * clone() const override { return new ReturnStmt( *this ); }
         virtual void accept( Visitor & v ) override { v.visit( this ); }
         virtual Statement * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
+        Expression *get_expr() { return expr; }
+        void set_expr( Expression *newValue ) { expr = newValue; }
+        virtual ReturnStmt *clone() const override { return new ReturnStmt( *this ); }
+        virtual void accept( Visitor &v ) override { v.visit( this ); }
+        virtual Statement *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
+        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
 };
 …
         ThrowStmt( Kind kind, Expression * expr, Expression * target = nullptr );
         ThrowStmt( const ThrowStmt & other );
+        ThrowStmt( const ThrowStmt &other );
         virtual ~ThrowStmt();
 …
         void set_target( Expression * newTarget ) { target = newTarget; }
         virtual ThrowStmt * clone() const override { return new ThrowStmt( *this ); }
         virtual void accept( Visitor & v ) override { v.visit( this ); }
         virtual Statement * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
+        virtual ThrowStmt *clone() const override { return new ThrowStmt( *this ); }
+        virtual void accept( Visitor &v ) override { v.visit( this ); }
+        virtual Statement *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
+        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
 };
 …
         FinallyStmt * finallyBlock;
         TryStmt( CompoundStmt * tryBlock, std::list<CatchStmt *> & handlers, FinallyStmt * finallyBlock = 0 );
         TryStmt( const TryStmt & other );
+        TryStmt( CompoundStmt *tryBlock, std::list<CatchStmt *> &handlers, FinallyStmt *finallyBlock = 0 );
+        TryStmt( const TryStmt &other );
         virtual ~TryStmt();
         CompoundStmt * get_block() const { return block; }
         void set_block( CompoundStmt * newValue ) { block = newValue; }
+        CompoundStmt *get_block() const { return block; }
+        void set_block( CompoundStmt *newValue ) { block = newValue; }
         std::list<CatchStmt *>& get_catchers() { return handlers; }
         FinallyStmt * get_finally() const { return finallyBlock; }
         void set_finally( FinallyStmt * newValue ) { finallyBlock = newValue; }
         virtual TryStmt * clone() const override { return new TryStmt( *this ); }
         virtual void accept( Visitor & v ) override { v.visit( this ); }
         virtual Statement * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
+        FinallyStmt *get_finally() const { return finallyBlock; }
+        void set_finally( FinallyStmt *newValue ) { finallyBlock = newValue; }
+        virtual TryStmt *clone() const override { return new TryStmt( *this ); }
+        virtual void accept( Visitor &v ) override { v.visit( this ); }
+        virtual Statement *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
+        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
 };
 …
         const Kind kind;
         Declaration * decl;
         Expression * cond;
         Statement * body;
         CatchStmt( Kind kind, Declaration * decl,
                    Expression * cond, Statement * body );
         CatchStmt( const CatchStmt & other );
+        Declaration *decl;
+        Expression *cond;
+        Statement *body;
+        CatchStmt( Kind kind, Declaration *decl,
+                   Expression *cond, Statement *body );
+        CatchStmt( const CatchStmt &other );
         virtual ~CatchStmt();
         Kind get_kind() { return kind; }
         Declaration * get_decl() { return decl; }
         void set_decl( Declaration * newValue ) { decl = newValue; }
         Expression * get_cond() { return cond; }
         void set_cond( Expression * newCond ) { cond = newCond; }
         Statement * get_body() { return body; }
         void set_body( Statement * newValue ) { body = newValue; }
         virtual CatchStmt * clone() const override { return new CatchStmt( *this ); }
         virtual void accept( Visitor & v ) override { v.visit( this ); }
         virtual Statement * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
+        Declaration *get_decl() { return decl; }
+        void set_decl( Declaration *newValue ) { decl = newValue; }
+        Expression *get_cond() { return cond; }
+        void set_cond( Expression *newCond ) { cond = newCond; }
+        Statement *get_body() { return body; }
+        void set_body( Statement *newValue ) { body = newValue; }
+        virtual CatchStmt *clone() const override { return new CatchStmt( *this ); }
+        virtual void accept( Visitor &v ) override { v.visit( this ); }
+        virtual Statement *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
+        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
 };
 class FinallyStmt : public Statement {
   public:
         CompoundStmt * block;
         FinallyStmt( CompoundStmt * block );
         FinallyStmt( const FinallyStmt & other );
+        CompoundStmt *block;
+        FinallyStmt( CompoundStmt *block );
+        FinallyStmt( const FinallyStmt &other );
         virtual ~FinallyStmt();
         CompoundStmt * get_block() const { return block; }
         void set_block( CompoundStmt * newValue ) { block = newValue; }
         virtual FinallyStmt * clone() const override { return new FinallyStmt( *this ); }
         virtual void accept( Visitor & v ) override { v.visit( this ); }
         virtual Statement * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
+        CompoundStmt *get_block() const { return block; }
+        void set_block( CompoundStmt *newValue ) { block = newValue; }
+        virtual FinallyStmt *clone() const override { return new FinallyStmt( *this ); }
+        virtual void accept( Visitor &v ) override { v.visit( this ); }
+        virtual Statement *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
+        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
 };
 …
         } orelse;
         virtual WaitForStmt * clone() const override { return new WaitForStmt( *this ); }
         virtual void accept( Visitor & v ) override { v.visit( this ); }
         virtual Statement * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
+        virtual WaitForStmt *clone() const override { return new WaitForStmt( *this ); }
+        virtual void accept( Visitor &v ) override { v.visit( this ); }
+        virtual Statement *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
+        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
 };
 …
 class DeclStmt : public Statement {
   public:
         Declaration * decl;
         DeclStmt( Declaration * decl );
         DeclStmt( const DeclStmt & other );
+        Declaration *decl;
+        DeclStmt( Declaration *decl );
+        DeclStmt( const DeclStmt &other );
         virtual ~DeclStmt();
+        Declaration * get_decl() const { return decl; }
+        void set_decl( Declaration * newValue ) { decl = newValue; }
+        virtual DeclStmt * clone() const override { return new DeclStmt( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual Statement * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
+};
+/// represents an implicit application of a constructor or destructor. Qualifiers are replaced immediately before and
+/// after the call so that qualified objects can be constructed with the same functions as unqualified objects.
+        Declaration *get_decl() const { return decl; }
+        void set_decl( Declaration *newValue ) { decl = newValue; }
+        virtual DeclStmt *clone() const override { return new DeclStmt( *this ); }
+        virtual void accept( Visitor &v ) override { v.visit( this ); }
+        virtual Statement *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
+        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
+};
+/// represents an implicit application of a constructor or destructor. Qualifiers are replaced
+/// immediately before and after the call so that qualified objects can be constructed
+/// with the same functions as unqualified objects.
 class ImplicitCtorDtorStmt : public Statement {
   public:
 …
         virtual ~ImplicitCtorDtorStmt();
         Statement * get_callStmt() const { return callStmt; }
+        Statement *get_callStmt() const { return callStmt; }
         void set_callStmt( Statement * newValue ) { callStmt = newValue; }
         virtual ImplicitCtorDtorStmt * clone() const override { return new ImplicitCtorDtorStmt( *this ); }
         virtual void accept( Visitor & v ) override { v.visit( this ); }
         virtual Statement * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
+        virtual ImplicitCtorDtorStmt *clone() const override { return new ImplicitCtorDtorStmt( *this ); }
+        virtual void accept( Visitor &v ) override { v.visit( this ); }
+        virtual Statement *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
+        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
 };

src/SynTree/SynTree.h

-              r933f32f
+              r6a9d4b4
 class NamedTypeDecl;
 class TypeDecl;
+class FtypeDecl;
+class DtypeDecl;
 class TypedefDecl;
 class AsmDecl;
 …
 class ConstructorExpr;
 class CompoundLiteralExpr;
+class UntypedValofExpr;
 class RangeExpr;
 class UntypedTupleExpr;
 …
 class ConstructorInit;
+class Subrange;
 //template <class T>    // emulate a union with templates?
 class Constant;

src/SynTree/Type.cc

-              r933f32f
+              r6a9d4b4
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Jan 31 21:54:16 2019
 // Update Count     : 43
+// Last Modified On : Fri Jun 22 10:17:19 2018
+// Update Count     : 39
 //
 #include "Type.h"
 …
 const char *BasicType::typeNames[] = {
-#if 0
         "_Bool",
         "char",
 …
         "unsigned __int128",
         "__float80",
+        "__float128",
+        "_Float16",
+        "_Float32",
+        "_Float32x",
+        "_Float64",
+        "_Float64x",
+        "_Float128",
+        "_Float128x",
+        "_Float16 _Complex",
+        "_Float32 _Complex",
+        "_Float32x _Complex",
+        "_Float64 _Complex",
+        "_Float64x _Complex",
+        "_Float128 _Complex",
+        "_Float128x _Complex",
+#endif
+        "_Bool",
+        "char",
+        "signed char",
+        "unsigned char",
+        "signed short int",
+        "unsigned short int",
+        "signed int",
+        "unsigned int",
+        "signed long int",
+        "unsigned long int",
+        "signed long long int",
+        "unsigned long long int",
+        "__int128",
+        "unsigned __int128",
+        "_Float16",
+        "_Float16 _Complex",
+        "_Float32",
+        "_Float32 _Complex",
+        "float",
+        "float _Complex",
+        //"float _Imaginary",
+        "_Float32x",
+        "_Float32x _Complex",
+        "_Float64",
+        "_Float64 _Complex",
+        "double",
+        "double _Complex",
+        //"double _Imaginary",
+        "_Float64x",
+        "_Float64x _Complex",
+        "__float80",
+        "_Float128",
+        "_Float128 _Complex",
+        "__float128",
+        "long double",
+        "long double _Complex",
+        //"long double _Imaginary",
+        "_Float128x",
+        "_Float128x _Complex",
+        "__float128"
 };
 static_assert(

src/SynTree/Type.h

-              r933f32f
+              r6a9d4b4
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Feb 14 17:11:24 2019
 // Update Count     : 169
+// Last Modified On : Mon Sep 25 14:14:01 2017
+// Update Count     : 154
 //
 …
 class BasicType : public Type {
   public:
-        // GENERATED START, DO NOT EDIT
-        // GENERATED BY BasicTypes-gen.cc
         enum Kind {
                 Bool,
 …
                 LongLongSignedInt,
                 LongLongUnsignedInt,
+                Float,
+                Double,
+                LongDouble,
+                FloatComplex,
+                DoubleComplex,
+                LongDoubleComplex,
+                FloatImaginary,
+                DoubleImaginary,
+                LongDoubleImaginary,
                 SignedInt128,
                 UnsignedInt128,
+                uFloat16,
+                uFloat16Complex,
+                uFloat32,
+                uFloat32Complex,
+                Float,
+                FloatComplex,
+                uFloat32x,
+                uFloat32xComplex,
+                uFloat64,
+                uFloat64Complex,
+                Double,
+                DoubleComplex,
+                uFloat64x,
+                uFloat64xComplex,
+                uuFloat80,
+                uFloat128,
+                uFloat128Complex,
+                uuFloat128,
+                LongDouble,
+                LongDoubleComplex,
+                uFloat128x,
+                uFloat128xComplex,
+                Float80,
+                Float128,
                 NUMBER_OF_BASIC_TYPES
         } kind;
-        // GENERATED END
         static const char *typeNames[];                                         // string names for basic types, MUST MATCH with Kind

src/SynTree/TypeSubstitution.cc

-              r933f32f
+              r6a9d4b4
+}
-void TypeSubstitution::addVar( std::string formalExpr, Expression *actualExpr ) {
-        varEnv[ formalExpr ] = actualExpr;
+}
 void TypeSubstitution::remove( std::string formalType ) {
         TypeEnvType::iterator i = typeEnv.find( formalType );
 …
 namespace {
         struct EnvTrimmer {
+                const TypeSubstitution * env;
+                TypeSubstitution * newEnv;
+                EnvTrimmer( const TypeSubstitution * env, TypeSubstitution * newEnv ) : env( env ), newEnv( newEnv ){}
+                TypeSubstitution * env, * newEnv;
+                EnvTrimmer( TypeSubstitution * env, TypeSubstitution * newEnv ) : env( env ), newEnv( newEnv ){}
                 void previsit( TypeDecl * tyDecl ) {
                         // transfer known bindings for seen type variables
 …
 /// reduce environment to just the parts that are referenced in a given expression
 TypeSubstitution * TypeSubstitution::newFromExpr( Expression * expr, const TypeSubstitution * env ) {
+TypeSubstitution * TypeSubstitution::newFromExpr( Expression * expr, TypeSubstitution * env ) {
         if ( env ) {
                 TypeSubstitution * newEnv = new TypeSubstitution();

src/SynTree/TypeSubstitution.h

-              r933f32f
+              r6a9d4b4
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Tue Apr 30 22:52:47 2019
 // Update Count     : 9
+// Last Modified On : Sat Jul 22 09:52:24 2017
+// Update Count     : 3
 //
 …
 #include <iosfwd>                  // for ostream
 #include <list>                    // for list<>::iterator, _List_iterator
 #include <unordered_map>
 #include <unordered_set>
+#include <map>                     // for _Rb_tree_iterator, map, map<>::val...
+#include <set>                     // for set
 #include <string>                  // for string, operator!=
 #include <utility>                 // for pair
 …
         TypeSubstitution &operator=( const TypeSubstitution &other );
         template< typename SynTreeClass > int apply( SynTreeClass *&input ) const;
         template< typename SynTreeClass > int applyFree( SynTreeClass *&input ) const;
+        template< typename SynTreeClass > int apply( SynTreeClass *&input );
+        template< typename SynTreeClass > int applyFree( SynTreeClass *&input );
         void add( std::string formalType, Type *actualType );
 …
         bool empty() const;
-        void addVar( std::string formalExpr, Expression *actualExpr );
         template< typename FormalIterator, typename ActualIterator >
         void add( FormalIterator formalBegin, FormalIterator formalEnd, ActualIterator actualBegin );
 …
         /// create a new TypeSubstitution using bindings from env containing all of the type variables in expr
         static TypeSubstitution * newFromExpr( Expression * expr, const TypeSubstitution * env );
+        static TypeSubstitution * newFromExpr( Expression * expr, TypeSubstitution * env );
         void normalize();
 …
         friend class PassVisitor;
         typedef std::unordered_map< std::string, Type * > TypeEnvType;
         typedef std::unordered_map< std::string, Expression * > VarEnvType;
+        typedef std::map< std::string, Type* > TypeEnvType;
+        typedef std::map< std::string, Expression* > VarEnvType;
         TypeEnvType typeEnv;
         VarEnvType varEnv;
 …
         auto begin() const -> decltype( typeEnv.begin() ) { return typeEnv.begin(); }
         auto   end() const -> decltype( typeEnv.  end() ) { return typeEnv.  end(); }
-        auto beginVar()       -> decltype( varEnv.begin() ) { return varEnv.begin(); }
-        auto   endVar()       -> decltype( varEnv.  end() ) { return varEnv.  end(); }
-        auto beginVar() const -> decltype( varEnv.begin() ) { return varEnv.begin(); }
-        auto   endVar() const -> decltype( varEnv.  end() ) { return varEnv.  end(); }
 };
 …
         ActualIterator actualIt = actualBegin;
         for ( ; formalIt != formalEnd; ++formalIt, ++actualIt ) {
                 if ( TypeDecl *formal = dynamic_cast< TypeDecl * >( *formalIt ) ) {
                         if ( TypeExpr *actual = dynamic_cast< TypeExpr * >( *actualIt ) ) {
+                if ( TypeDecl *formal = dynamic_cast< TypeDecl* >( *formalIt ) ) {
+                        if ( TypeExpr *actual = dynamic_cast< TypeExpr* >( *actualIt ) ) {
                                 if ( formal->get_name() != "" ) {
                                         TypeEnvType::iterator i = typeEnv.find( formal->get_name() );
 …
 // definitition must happen after PassVisitor is included so that WithGuards can be used
 struct TypeSubstitution::Substituter : public WithGuards, public WithVisitorRef<Substituter> {
                 Substituter( const TypeSubstitution & sub, bool freeOnly ) : sub( sub ), freeOnly( freeOnly ) {}
+                Substituter( TypeSubstitution & sub, bool freeOnly ) : sub( sub ), freeOnly( freeOnly ) {}
                 Type * postmutate( TypeInstType * aggregateUseType );
 …
                 void premutate( UnionInstType * aggregateUseType );
                 const TypeSubstitution & sub;
+                TypeSubstitution & sub;
                 int subCount = 0;
                 bool freeOnly;
                 typedef std::unordered_set< std::string > BoundVarsType;
+                typedef std::set< std::string > BoundVarsType;
                 BoundVarsType boundVars;
 };
 template< typename SynTreeClass >
 int TypeSubstitution::apply( SynTreeClass *&input ) const {
+int TypeSubstitution::apply( SynTreeClass *&input ) {
         assert( input );
         PassVisitor<Substituter> sub( *this, false );
 …
 template< typename SynTreeClass >
 int TypeSubstitution::applyFree( SynTreeClass *&input ) const {
+int TypeSubstitution::applyFree( SynTreeClass *&input ) {
         assert( input );
         PassVisitor<Substituter> sub( *this, true );

src/SynTree/Visitor.h

r933f32f	r6a9d4b4
123	123	virtual void visit( ConstructorInit * ctorInit ) = 0;
124	124
	125	virtual void visit( Subrange * subrange ) = 0;
	126
125	127	virtual void visit( Constant * constant ) = 0;
126	128

src/SynTree/module.mk

-              r933f32f
+              r6a9d4b4
 ###############################################################################
+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/Statement.cc \
+      SynTree/CompoundStmt.cc \
+      SynTree/DeclStmt.cc \
+      SynTree/Declaration.cc \
+      SynTree/DeclarationWithType.cc \
+      SynTree/ObjectDecl.cc \
+      SynTree/FunctionDecl.cc \
+      SynTree/AggregateDecl.cc \
+      SynTree/NamedTypeDecl.cc \
+      SynTree/TypeDecl.cc \
+      SynTree/Initializer.cc \
+      SynTree/TypeSubstitution.cc \
+      SynTree/Attribute.cc \
+      SynTree/DeclReplacer.cc
+SRC += 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/Statement.cc \
+       SynTree/CompoundStmt.cc \
+       SynTree/DeclStmt.cc \
+       SynTree/Declaration.cc \
+       SynTree/DeclarationWithType.cc \
+       SynTree/ObjectDecl.cc \
+       SynTree/FunctionDecl.cc \
+       SynTree/AggregateDecl.cc \
+       SynTree/NamedTypeDecl.cc \
+       SynTree/TypeDecl.cc \
+       SynTree/Initializer.cc \
+       SynTree/TypeSubstitution.cc \
+       SynTree/Attribute.cc \
+       SynTree/DeclReplacer.cc
-SRC += $(SRC_SYNTREE)
-SRCDEMANGLE += $(SRC_SYNTREE)

src/Tuples/TupleExpansion.cc

-              r933f32f
+              r6a9d4b4
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed Feb 13 18:14:12 2019
 // Update Count     : 21
+// Last Modified On : Wed Jun 21 17:35:04 2017
+// Update Count     : 19
 //
 …
 #include <cassert>                // for assert
 #include <list>                   // for list
+#include <vector>
+#include "AST/CVQualifiers.hpp"
+#include "AST/Expr.hpp"
+#include "AST/Node.hpp"
+#include "AST/Type.hpp"
 #include "Common/PassVisitor.h"   // for PassVisitor, WithDeclsToAdd, WithGu...
 #include "Common/ScopedMap.h"     // for ScopedMap
 …
                 };
                 struct TupleTypeReplacer : public WithDeclsToAdd, public WithGuards, public WithConstTypeSubstitution {
+                struct TupleTypeReplacer : public WithDeclsToAdd, public WithGuards, public WithTypeSubstitution {
                         Type * postmutate( TupleType * tupleType );
 …
                 return new TupleType( qualifiers, types );
+        }
-        const ast::Type * makeTupleType( const std::vector<ast::ptr<ast::Expr>> & exprs ) {
-                (void) exprs;
-                #warning Not implemented; needs Type.cpp in build
-                assertf(false, "Not implemented; needs Type.cpp in build");
-                // // produce the TupleType which aggregates the types of the exprs
-                // std::vector<ast::ptr<ast::Type>> types;
-                // ast::CV::Qualifiers quals{
-                //      ast::CV::Const | ast::CV::Volatile | ast::CV::Restrict | ast::CV::Lvalue |
-                //      ast::CV::Atomic | ast::CV::Mutex };
-                // for ( const ast::Expr * expr : exprs ) {
-                //      assert( expr->result );
-                //      // if the type of any expr is void, the type of the entire tuple is void
-                //      if ( expr->result->isVoid() ) return new ast::VoidType{};
-                //      // qualifiers on the tuple type are the qualifiers that exist on all components
-                //      quals &= expr->result->qualifiers;
-                //      types.emplace_back( expr->result );
-                // }
-                // if ( exprs.empty() ) { quals = ast::CV::Qualifiers{}; }
-                // return new ast::TupleType{ std::move(types), quals };
+        }
         TypeInstType * isTtype( Type * type ) {

src/Tuples/Tuples.h

-              r933f32f
+              r6a9d4b4
 #include <vector>
-#include "AST/Fwd.hpp"
-#include "AST/Node.hpp"
 #include "SynTree/Expression.h"
 #include "SynTree/Declaration.h"
 …
 namespace Tuples {
         // TupleAssignment.cc
         void handleTupleAssignment( ResolvExpr::AlternativeFinder & currentFinder, UntypedExpr * assign,
+        void handleTupleAssignment( ResolvExpr::AlternativeFinder & currentFinder, UntypedExpr * assign,
                 std::vector< ResolvExpr::AlternativeFinder >& args );
         // TupleExpansion.cc
         /// expands z.[a, b.[x, y], c] into [z.a, z.b.x, z.b.y, z.c], inserting UniqueExprs as appropriate
 …
         /// returns VoidType if any of the expressions have Voidtype, otherwise TupleType of the Expression result types
         Type * makeTupleType( const std::list< Expression * > & exprs );
-        const ast::Type * makeTupleType( const std::vector<ast::ptr<ast::Expr>> & exprs );
         /// returns a TypeInstType if `type` is a ttype, nullptr otherwise
         TypeInstType * isTtype( Type * type );
-        const ast::TypeInstType * isTtype( const ast::Type * type );
         /// returns true if the expression may contain side-effects.

src/Tuples/module.mk

-              r933f32f
+              r6a9d4b4
 ###############################################################################
+SRC += Tuples/TupleAssignment.cc Tuples/TupleExpansion.cc Tuples/Explode.cc
+SRCDEMANGLE += Tuples/TupleAssignment.cc Tuples/TupleExpansion.cc Tuples/Explode.cc
+SRC +=  Tuples/TupleAssignment.cc \
+        Tuples/TupleExpansion.cc \
+        Tuples/Explode.cc

src/Validate/module.mk

r933f32f	r6a9d4b4
15	15	###############################################################################
16	16
17		SRC += Validate/HandleAttributes.cc ~~Validate/FindSpecialDecls.cc~~
18		~~SRCDEMANGLE += Validate/HandleAttributes.cc~~ Validate/FindSpecialDecls.cc
	17	SRC += Validate/HandleAttributes.cc \
	18	Validate/FindSpecialDecls.cc

src/config.h.in

-              r933f32f
+              r6a9d4b4
 #undef CFA_VERSION_SHORT
+/* Have compiler warning cast-function-type. */
+#undef HAVE_CAST_FUNCTION_TYPE
+/* Define to one of `_getb67', `GETB67', `getb67' for Cray-2 and Cray-YMP
+   systems. This function is required for `alloca.c' support on those systems.
+   */
+#undef CRAY_STACKSEG_END
+/* Define to 1 if using `alloca.c'. */
+#undef C_ALLOCA
+/* Define to 1 if you have `alloca', as a function or macro. */
+#undef HAVE_ALLOCA
+/* Define to 1 if you have <alloca.h> and it should be used (not on Ultrix).
+   */
+#undef HAVE_ALLOCA_H
 /* Define to 1 if you have the <dlfcn.h> header file. */
 #undef HAVE_DLFCN_H
+/* Define to 1 if you have the <fenv.h> header file. */
+#undef HAVE_FENV_H
+/* Define to 1 if you have the <float.h> header file. */
+#undef HAVE_FLOAT_H
 /* Define to 1 if you have the <inttypes.h> header file. */
 #undef HAVE_INTTYPES_H
-/* Have keywords _FloatXX. */
-#undef HAVE_KEYWORDS_FLOATXX
 /* Define to 1 if you have the <libintl.h> header file. */
 #undef HAVE_LIBINTL_H
+/* Define to 1 if you have the <limits.h> header file. */
+#undef HAVE_LIMITS_H
 /* Define to 1 if you have the <malloc.h> header file. */
 #undef HAVE_MALLOC_H
 …
 #undef HAVE_MEMORY_H
+/* Define to 1 if you have the `memset' function. */
+#undef HAVE_MEMSET
+/* Define to 1 if you have the `putenv' function. */
+#undef HAVE_PUTENV
+/* Define to 1 if stdbool.h conforms to C99. */
+#undef HAVE_STDBOOL_H
+/* Define to 1 if you have the <stddef.h> header file. */
+#undef HAVE_STDDEF_H
 /* Define to 1 if you have the <stdint.h> header file. */
 #undef HAVE_STDINT_H
 …
 #undef HAVE_STDLIB_H
+/* Define to 1 if you have the `strchr' function. */
+#undef HAVE_STRCHR
 /* Define to 1 if you have the <strings.h> header file. */
 #undef HAVE_STRINGS_H
 …
 #undef HAVE_STRING_H
+/* Define to 1 if you have the `strtol' function. */
+#undef HAVE_STRTOL
 /* Define to 1 if you have the <sys/stat.h> header file. */
 #undef HAVE_SYS_STAT_H
 …
 #undef HAVE_UNISTD_H
 /* Define to 1 if the system has the type `_Float32'. */
 #undef HAVE__FLOAT32
+/* Define to 1 if the system has the type `_Bool'. */
+#undef HAVE__BOOL
 /* Define to the sub-directory where libtool stores uninstalled libraries. */
 …
 /* Define to the version of this package. */
 #undef PACKAGE_VERSION
+/* If using the C implementation of alloca, define if you know the
+   direction of stack growth for your system; otherwise it will be
+   automatically deduced at runtime.
+        STACK_DIRECTION > 0 => grows toward higher addresses
+        STACK_DIRECTION < 0 => grows toward lower addresses
+        STACK_DIRECTION = 0 => direction of growth unknown */
+#undef STACK_DIRECTION
 /* Define to 1 if you have the ANSI C header files. */
 …
    `char[]'. */
 #undef YYTEXT_POINTER
+/* Define for Solaris 2.5.1 so the uint32_t typedef from <sys/synch.h>,
+   <pthread.h>, or <semaphore.h> is not used. If the typedef were allowed, the
+   #define below would cause a syntax error. */
+#undef _UINT32_T
+/* Define for Solaris 2.5.1 so the uint8_t typedef from <sys/synch.h>,
+   <pthread.h>, or <semaphore.h> is not used. If the typedef were allowed, the
+   #define below would cause a syntax error. */
+#undef _UINT8_T
+/* Define to `__inline__' or `__inline' if that's what the C compiler
+   calls it, or to nothing if 'inline' is not supported under any name.  */
+#ifndef __cplusplus
+#undef inline
+#endif
+/* Define to the type of a signed integer type of width exactly 16 bits if
+   such a type exists and the standard includes do not define it. */
+#undef int16_t
+/* Define to the type of a signed integer type of width exactly 32 bits if
+   such a type exists and the standard includes do not define it. */
+#undef int32_t
+/* Define to the type of a signed integer type of width exactly 8 bits if such
+   a type exists and the standard includes do not define it. */
+#undef int8_t
+/* Define to the equivalent of the C99 'restrict' keyword, or to
+   nothing if this is not supported.  Do not define if restrict is
+   supported directly.  */
+#undef restrict
+/* Work around a bug in Sun C++: it does not support _Restrict or
+   __restrict__, even though the corresponding Sun C compiler ends up with
+   "#define restrict _Restrict" or "#define restrict __restrict__" in the
+   previous line.  Perhaps some future version of Sun C++ will work with
+   restrict; if so, hopefully it defines __RESTRICT like Sun C does.  */
+#if defined __SUNPRO_CC && !defined __RESTRICT
+# define _Restrict
+# define __restrict__
+#endif
+/* Define to `unsigned int' if <sys/types.h> does not define. */
+#undef size_t
+/* Define to the type of an unsigned integer type of width exactly 16 bits if
+   such a type exists and the standard includes do not define it. */
+#undef uint16_t
+/* Define to the type of an unsigned integer type of width exactly 32 bits if
+   such a type exists and the standard includes do not define it. */
+#undef uint32_t
+/* Define to the type of an unsigned integer type of width exactly 8 bits if
+   such a type exists and the standard includes do not define it. */
+#undef uint8_t

src/include/cassert

r933f32f	r6a9d4b4
45	45	}
46	46
47		~~extern void abort(const char *fmt, ... ) noexcept __attribute__((noreturn, format(printf, 1, 2)));~~
48	47	// Local Variables: //
49	48	// tab-width: 4 //

src/main.cc

-              r933f32f
+              r6a9d4b4
 // main.cc --
 //
 // Author           : Peter Buhr and Rob Schluntz
+// Author           : Richard C. Bilson
 // Created On       : Fri May 15 23:12:02 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri May  3 16:10:52 2019
 // Update Count     : 599
+// Last Modified On : Wed Dec 26 08:11:19 2018
+// Update Count     : 499
 //
 …
 #include <fstream>                          // for ofstream
 #include <iostream>                         // for operator<<, basic_ostream
-#include <iomanip>
 #include <iterator>                         // for back_inserter
 #include <list>                             // for list
 …
 #include "CodeTools/TrackLoc.h"             // for fillLocations
 #include "Common/CompilerError.h"           // for CompilerError
 #include "Common/Stats.h"
+#include "Common/Heap.h"
 #include "Common/PassVisitor.h"
-// #include "AST/Pass.hpp"
 #include "Common/SemanticError.h"           // for SemanticError
 #include "Common/UnimplementedError.h"      // for UnimplementedError
 …
 using namespace std;
+static void NewPass( const char * const name ) {
+        Stats::Heap::newPass( name );
+        using namespace Stats::Counters;
+        {
+                static auto group = build<CounterGroup>( "Pass Visitor" );
+                auto pass = build<CounterGroup>( name, group );
+                pass_visitor_stats.depth = 0;
+                pass_visitor_stats.avg = build<AverageCounter<double>>( "Average Depth", pass );
+                pass_visitor_stats.max = build<MaxCounter<double>>( "Max Depth", pass );
+        }
+        {
+                static auto group = build<CounterGroup>( "Syntax Node" );
+                auto pass = build<CounterGroup>( name, group );
+                BaseSyntaxNode::new_nodes = build<SimpleCounter>( "Allocs", pass );
+        }
+}
+#define PASS( name, pass )                  \
+#define PASS(name, pass)                   \
         if ( errorp ) { cerr << name << endl; } \
+        NewPass(name);                          \
+        Stats::Time::StartBlock(name);          \
+        pass;                                   \
+        Stats::Time::StopBlock();
+        HeapStats::newPass(name);               \
+        pass;
 LinkageSpec::Spec linkage = LinkageSpec::Cforall;
 …
 DeclarationNode * parseTree = nullptr;                                  // program parse tree
 static std::string PreludeDirector = "";
+std::string PreludeDirector = "";
 static void parse_cmdline( int argc, char *argv[], const char *& filename );
 …
 } // backtrace
 static void sigSegvBusHandler( int sig_num ) {
+void sigSegvBusHandler( int sig_num ) {
         cerr << "*CFA runtime error* program cfa-cpp terminated with "
                  <<     (sig_num == SIGSEGV ? "segment fault" : "bus error")
 …
         backtrace( 2 );                                                                         // skip first 2 stack frames
         //_exit( EXIT_FAILURE );
         abort();                                                                                        // cause core dump for debugging
+        abort();
 } // sigSegvBusHandler
 static void sigAbortHandler( __attribute__((unused)) int sig_num ) {
+void sigAbortHandler( __attribute__((unused)) int sig_num ) {
         backtrace( 6 );                                                                         // skip first 6 stack frames
         signal( SIGABRT, SIG_DFL);                                                      // reset default signal handler
                 raise( SIGABRT );                                                                       // reraise SIGABRT
+    raise( SIGABRT );                                                                   // reraise SIGABRT
 } // sigAbortHandler
 …
 int main( int argc, char * argv[] ) {
         FILE * input;                                                                           // use FILE rather than istream because yyin is FILE
         ostream * output = & cout;
         const char * filename = nullptr;
+        ostream *output = & cout;
+        const char *filename = nullptr;
         list< Declaration * > translationUnit;
 …
                 } // if
-                Stats::Time::StartGlobal();
-                NewPass("Parse");
-                Stats::Time::StartBlock("Parse");
                 // read in the builtins, extras, and the prelude
                 if ( ! nopreludep ) {                                                   // include gcc builtins
 …
                         parseTree->printList( cout );
                         delete parseTree;
                         return EXIT_SUCCESS;
+                        return 0;
                 } // if
 …
                 if ( astp ) {
                         dump( translationUnit );
                         return EXIT_SUCCESS;
+                        return 0;
                 } // if
 …
                 // works okay for now.
                 CodeTools::fillLocations( translationUnit );
-                Stats::Time::StopBlock();
                 // add the assignment statement after the initialization of a type parameter
                 PASS( "Validate", SymTab::validate( translationUnit, symtabp ) );
+                PASS( "validate", SymTab::validate( translationUnit, symtabp ) );
                 if ( symtabp ) {
                         deleteAll( translationUnit );
                         return EXIT_SUCCESS;
+                        return 0;
                 } // if
 …
                         PassVisitor<ResolvExpr::AlternativePrinter> printer( cout );
                         acceptAll( translationUnit, printer );
                         return EXIT_SUCCESS;
+                        return 0;
                 } // if
                 if ( validp ) {
                         dump( translationUnit );
                         return EXIT_SUCCESS;
                 } // if
                 PASS( "Fix Labels", ControlStruct::fixLabels( translationUnit ) );
                 PASS( "Fix Names", CodeGen::fixNames( translationUnit ) );
                 PASS( "Gen Init", InitTweak::genInit( translationUnit ) );
                 PASS( "Expand Member Tuples" , Tuples::expandMemberTuples( translationUnit ) );
+                        return 0;
+                } // if
+                PASS( "fixLabels", ControlStruct::fixLabels( translationUnit ) );
+                PASS( "fixNames", CodeGen::fixNames( translationUnit ) );
+                PASS( "genInit", InitTweak::genInit( translationUnit ) );
+                PASS( "expandMemberTuples" , Tuples::expandMemberTuples( translationUnit ) );
                 if ( libcfap ) {
                         // generate the bodies of cfa library functions
 …
                         CodeTools::printDeclStats( translationUnit );
                         deleteAll( translationUnit );
                         return EXIT_SUCCESS;
                 } // if
+                        return 0;
+                }
                 if ( bresolvep ) {
                         dump( translationUnit );
                         return EXIT_SUCCESS;
+                        return 0;
                 } // if
 …
                 if ( resolvprotop ) {
                         CodeTools::dumpAsResolvProto( translationUnit );
                         return EXIT_SUCCESS;
                 } // if
                 PASS( "Resolve", ResolvExpr::resolve( translationUnit ) );
+                        return 0;
+                }
+                PASS( "resolve", ResolvExpr::resolve( translationUnit ) );
                 if ( exprp ) {
                         dump( translationUnit );
                         return EXIT_SUCCESS;
+                        return 0;
                 } // if
                 // fix ObjectDecl - replaces ConstructorInit nodes
                 PASS( "Fix Init", InitTweak::fix( translationUnit, buildingLibrary() ) );
+                PASS( "fixInit", InitTweak::fix( translationUnit, buildingLibrary() ) );
                 if ( ctorinitp ) {
                         dump ( translationUnit );
                         return EXIT_SUCCESS;
                 } // if
                 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
                 PASS( "Translate EHM" , ControlStruct::translateEHM( translationUnit ) );
                 PASS( "Gen Waitfor" , Concurrency::generateWaitFor( translationUnit ) );
                 PASS( "Convert Specializations",  GenPoly::convertSpecializations( translationUnit ) ); // needs to happen before tuple types are expanded
                 PASS( "Expand Tuples", Tuples::expandTuples( translationUnit ) ); // xxx - is this the right place for this?
+                        return 0;
+                } // if
+                PASS( "expandUniqueExpr", 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
+                PASS( "translateEHM" , ControlStruct::translateEHM( translationUnit ) );
+                PASS( "generateWaitfor" , Concurrency::generateWaitFor( translationUnit ) );
+                PASS( "convertSpecializations",  GenPoly::convertSpecializations( translationUnit ) ); // needs to happen before tuple types are expanded
+                PASS( "expandTuples", Tuples::expandTuples( translationUnit ) ); // xxx - is this the right place for this?
                 if ( tuplep ) {
                         dump( translationUnit );
                         return EXIT_SUCCESS;
                 } // if
                 PASS( "Virtual Expand Casts", Virtual::expandCasts( translationUnit ) ); // Must come after translateEHM
                 PASS( "Instantiate Generics", GenPoly::instantiateGeneric( translationUnit ) );
+                        return 0;
+                }
+                PASS( "virtual expandCasts", Virtual::expandCasts( translationUnit ) ); // Must come after translateEHM
+                PASS( "instantiateGenerics", GenPoly::instantiateGeneric( translationUnit ) );
                 if ( genericsp ) {
                         dump( translationUnit );
                         return EXIT_SUCCESS;
                 } // if
                 PASS( "Convert L-Value", GenPoly::convertLvalue( translationUnit ) );
+                        return 0;
+                }
+                PASS( "convertLvalue", GenPoly::convertLvalue( translationUnit ) );
                 if ( bboxp ) {
                         dump( translationUnit );
                         return EXIT_SUCCESS;
                 } // if
                 PASS( "Box", GenPoly::box( translationUnit ) );
+                        return 0;
+                } // if
+                PASS( "box", GenPoly::box( translationUnit ) );
                 if ( bcodegenp ) {
                         dump( translationUnit );
                         return EXIT_SUCCESS;
                 } // if
+                        return 0;
+                }
                 if ( optind < argc ) {                                                  // any commands after the flags and input file ? => output file name
 …
                 CodeTools::fillLocations( translationUnit );
                 PASS( "Code Gen", CodeGen::generate( translationUnit, *output, ! genproto, prettycodegenp, true, linemarks ) );
+                PASS( "codegen", CodeGen::generate( translationUnit, *output, ! noprotop, prettycodegenp, true, linemarks ) );
                 CodeGen::FixMain::fix( *output, (PreludeDirector + "/bootloader.c").c_str() );
 …
                         delete output;
                 } // if
                 return EXIT_FAILURE;
+                return 1;
         } catch ( UnimplementedError &e ) {
                 cout << "Sorry, " << e.get_what() << " is not currently implemented" << endl;
 …
                         delete output;
                 } // if
                 return EXIT_FAILURE;
+                return 1;
         } catch ( CompilerError &e ) {
                 cerr << "Compiler Error: " << e.get_what() << endl;
 …
                         delete output;
                 } // if
                 return EXIT_FAILURE;
         } catch ( ... ) {
+                return 1;
+        } catch(...) {
                 std::exception_ptr eptr = std::current_exception();
                 try {
                         if (eptr) {
                                 std::rethrow_exception(eptr);
+                        } else {
+                                std::cerr << "Exception Uncaught and Unknown" << std::endl;
+                        } // if
+                        }
+                        else {
+                                std::cerr << "Exception Uncaught and Unkown" << std::endl;
+                        }
                 } catch(const std::exception& e) {
                         std::cerr << "Uncaught Exception \"" << e.what() << "\"\n";
                 } // try
                 return EXIT_FAILURE;
         } // try
+                }
+                return 1;
+        }// try
         deleteAll( translationUnit );
         Stats::print();
         return EXIT_SUCCESS;
+        if(!libcfap && !treep) HeapStats::printStats();
+        return 0;
 } // main
+static const char optstring[] = ":hlLmNn:pP:S:twW:D:F:";
+enum { PreludeDir = 128 };
+static struct option long_opts[] = {
+        { "help", no_argument, nullptr, 'h' },
+        { "libcfa", no_argument, nullptr, 'l' },
+        { "linemarks", no_argument, nullptr, 'L' },
+        { "no-main", no_argument, 0, 'm' },
+        { "no-linemarks", no_argument, nullptr, 'N' },
+        { "no-prelude", no_argument, nullptr, 'n' },
+        { "prototypes", no_argument, nullptr, 'p' },
+        { "print", required_argument, nullptr, 'P' },
+        { "prelude-dir", required_argument, nullptr, PreludeDir },
+        { "statistics", required_argument, nullptr, 'S' },
+        { "tree", no_argument, nullptr, 't' },
+        { "", no_argument, nullptr, 0 },                                        // -w
+        { "", no_argument, nullptr, 0 },                                        // -W
+        { "", no_argument, nullptr, 0 },                                        // -D
+        { "", no_argument, nullptr, 0 },                                        // -F
+        { nullptr, 0, nullptr, 0 }
+}; // long_opts
+static const char * description[] = {
+        "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
+        "<directory> prelude directory for debug/nodebug",      // no flag
+        "<option-list> enable profiling information:\n          counters,heap,time,all,none", // -S
+        "build in tree",                                                                        // -t
+        "",                                                                                                     // -w
+        "",                                                                                                     // -W
+        "",                                                                                                     // -D
+        "",                                                                                                     // -F
+}; // description
+static_assert( sizeof( long_opts ) / sizeof( long_opts[0] ) - 1 == sizeof( description ) / sizeof( description[0] ), "Long opts and description must match" );
+static struct Printopts {
+        const char * name;
+        int & flag;
+        int val;
+        const char * descript;
+} printopts[] = {
+        { "altexpr", expraltp, true, "alternatives for expressions" },
+        { "ascodegen", codegenp, true, "as codegen rather than AST" },
+        { "ast", astp, true, "AST after parsing" },
+        { "astdecl", validp, true, "AST after declaration validation pass" },
+        { "asterr", errorp, true, "AST on error" },
+        { "astexpr", exprp, true, "AST after expression analysis" },
+        { "astgen", genericsp, true, "AST after instantiate generics" },
+        { "box", bboxp, true, "before box step" },
+        { "ctordtor", ctorinitp, true, "after ctor/dtor are replaced" },
+        { "codegen", bcodegenp, true, "before code generation" },
+        { "declstats", declstatsp, true, "code property statistics" },
+        { "parse", yydebug, true, "yacc (parsing) debug information" },
+        { "pretty", prettycodegenp, true, "prettyprint for ascodegen flag" },
+        { "resolver", bresolvep, true, "before resolver step" },
+        { "rproto", resolvprotop, true, "resolver-proto instance" },
+        { "rsteps", resolvep, true, "resolver steps" },
+        { "symevt", symtabp, true, "symbol table events" },
+        { "tree", parsep, true, "parse tree" },
+        { "tuple", tuplep, true, "after tuple expansion" },
+};
+enum { printoptsSize = sizeof( printopts ) / sizeof( printopts[0] ) };
+static void usage( char *argv[] ) {
+    cout << "Usage: " << argv[0] << " options are:" << endl;
+        int i = 0, j = 1;                                                                       // j skips starting colon
+        for ( ; long_opts[i].name != 0 && optstring[j] != '\0'; i += 1, j += 1 ) {
+                if ( long_opts[i].name[0] != '\0' ) {                   // hidden option, internal usage only
+                        if ( strcmp( long_opts[i].name, "prelude-dir" ) != 0 ) { // flag
+                                cout << "  -" << optstring[j] << ",";
+                        } else {                                                                        // no flag
+                                j -= 1;                                                                 // compensate
+                                cout << "     ";
+                        } // if
+                        cout << " --" << left << setw(12) << long_opts[i].name << "  ";
+                        if ( strcmp( long_opts[i].name, "print" ) == 0 ) {
+                                cout << "one of: " << endl;
+                                for ( int i = 0; i < printoptsSize; i += 1 ) {
+                                        cout << setw(10) << " " << left << setw(10) << printopts[i].name << "  " << printopts[i].descript << endl;
+                                } // for
+                        } else {
+                                cout << description[i] << endl;
+                        } // if
+                } // if
+                if ( optstring[j + 1] == ':' ) j += 1;
+        } // for
+        if ( long_opts[i].name != 0 || optstring[j] != '\0' ) assertf( false, "internal error, mismatch of option flags and names\n" );
+    exit( EXIT_FAILURE );
+} // usage
+static void parse_cmdline( int argc, char * argv[], const char *& filename ) {
+void parse_cmdline( int argc, char * argv[], const char *& filename ) {
+        enum { Ast, Bbox, Bresolver, CtorInitFix, DeclStats, Expr, ExprAlt, Grammar, LibCFA, Linemarks, Nolinemarks, Nopreamble, Parse, PreludeDir, Prototypes, Resolver, ResolvProto, Symbol, Tree, TupleExpansion, Validate, };
+        static struct option long_opts[] = {
+                { "ast", no_argument, 0, Ast },
+                { "before-box", no_argument, 0, Bbox },
+                { "before-resolver", no_argument, 0, Bresolver },
+                { "ctorinitfix", no_argument, 0, CtorInitFix },
+                { "decl-stats", no_argument, 0, DeclStats },
+                { "expr", no_argument, 0, Expr },
+                { "expralt", no_argument, 0, ExprAlt },
+                { "grammar", no_argument, 0, Grammar },
+                { "libcfa", no_argument, 0, LibCFA },
+                { "line-marks", no_argument, 0, Linemarks },
+                { "no-line-marks", no_argument, 0, Nolinemarks },
+                { "no-preamble", no_argument, 0, Nopreamble },
+                { "parse", no_argument, 0, Parse },
+                { "prelude-dir", required_argument, 0, PreludeDir },
+                { "no-prototypes", no_argument, 0, Prototypes },
+                { "resolver", no_argument, 0, Resolver },
+                { "resolv-proto", no_argument, 0, ResolvProto },
+                { "symbol", no_argument, 0, Symbol },
+                { "tree", no_argument, 0, Tree },
+                { "tuple-expansion", no_argument, 0, TupleExpansion },
+                { "validate", no_argument, 0, Validate },
+                { 0, 0, 0, 0 }
+        }; // long_opts
+        int long_index;
         opterr = 0;                                                                                     // (global) prevent getopt from printing error messages
         bool Wsuppress = false, Werror = false;
         int c;
         while ( (c = getopt_long( argc, argv, optstring, long_opts, nullptr )) != -1 ) {
+        while ( (c = getopt_long( argc, argv, "abBcCdefgGlLmnNpqrRstTvwW:yzZD:F:", long_opts, &long_index )) != -1 ) {
                 switch ( c ) {
+                  case 'h':                                                                             // help message
+                        usage( argv );                                                          // no return
+                        break;
+                  case Ast:
+                  case 'a':                                                                             // dump AST
+                        astp = true;
+                        break;
+                  case Bresolver:
+                  case 'b':                                                                             // print before resolver steps
+                        bresolvep = true;
+                        break;
+                  case 'B':                                                                             // print before box steps
+                        bboxp = true;
+                        break;
+                  case CtorInitFix:
+                  case 'c':                                                                             // print after constructors and destructors are replaced
+                        ctorinitp = true;
+                        break;
+                  case 'C':                                                                             // print before code generation
+                        bcodegenp = true;
+                        break;
+                  case DeclStats:
+                  case 'd':
+                    declstatsp = true;
+                        break;
+                  case Expr:
+                  case 'e':                                                                             // dump AST after expression analysis
+                        exprp = true;
+                        break;
+                  case ExprAlt:
+                  case 'f':                                                                             // print alternatives for expressions
+                        expraltp = true;
+                        break;
+                  case Grammar:
+                  case 'g':                                                                             // bison debugging info (grammar rules)
+                        yydebug = true;
+                        break;
+                  case 'G':                                                                             // dump AST after instantiate generics
+                        genericsp = true;
+                        break;
+                  case LibCFA:
                   case 'l':                                                                             // generate libcfa.c
                         libcfap = true;
                         break;
+                  case 'L':                                                                             // generate line marks
+                  case Linemarks:
+                  case 'L':                                                                             // print lines marks
                         linemarks = true;
                         break;
+                  case 'm':                                                                             // do not replace main
+                        nomainp = true;
+                        break;
+                  case 'N':                                                                             // do not generate line marks
+                  case Nopreamble:
+                  case 'n':                                                                             // do not read preamble
+                        nopreludep = true;
+                        break;
+                  case Nolinemarks:
+                  case 'N':                                                                             // suppress line marks
                         linemarks = false;
                         break;
+                  case 'n':                                                                             // do not read prelude
+                        nopreludep = true;
+                        break;
+                  case 'p':                                                                             // generate prototypes for prelude functions
+                        genproto = true;
+                        break;
+                  case 'P':                                                                             // print options
+                        for ( int i = 0;; i += 1 ) {
+                                if ( i == printoptsSize ) {
+                                        cout << "Unknown --print option " << optarg << endl;
+                                        goto Default;
+                                } // if
+                                if ( strcmp( optarg, printopts[i].name ) == 0 ) {
+                                        printopts[i].flag = printopts[i].val;
+                                        break;
+                                } // if
+                        } // for
+                        break;
+                  case PreludeDir:                                                              // prelude directory for debug/nodebug, hidden
+                        PreludeDirector = optarg;
+                        break;
+                  case 'S':                                                                             // enable profiling information, argument comma separated list of names
+                        Stats::parse_params( optarg );
+                        break;
+                  case Prototypes:
+                  case 'p':                                                                             // generate prototypes for preamble functions
+                        noprotop = true;
+                        break;
+                  case PreludeDir:
+                        PreludeDirector = optarg;
+                        break;
+                  case 'm':                                                                             // don't replace the main
+                        nomainp = true;
+                        break;
+                  case Parse:
+                  case 'q':                                                                             // dump parse tree
+                        parsep = true;
+                        break;
+                  case Resolver:
+                  case 'r':                                                                             // print resolver steps
+                        resolvep = true;
+                        break;
+                  case 'R':                                                                             // dump resolv-proto instance
+                        resolvprotop = true;
+                        break;
+                  case Symbol:
+                  case 's':                                                                             // print symbol table events
+                        symtabp = true;
+                        break;
+                  case Tree:
                   case 't':                                                                             // build in tree
                         treep = true;
                         break;
+                  case 'w':                                                                             // suppress all warnings, hidden
+                  case TupleExpansion:
+                  case 'T':                                                                             // print after tuple expansion
+                        tuplep = true;
+                        break;
+                  case 'v':                                                                             // dump AST after decl validation pass
+                        validp = true;
+                        break;
+                  case 'w':
                         Wsuppress = true;
                         break;
                   case 'W':                                                                             // coordinate gcc -W with CFA, hidden
+                  case 'W':
                         if ( strcmp( optarg, "all" ) == 0 ) {
                                 SemanticWarning_EnableAll();
 …
                         } // if
                         break;
+                  case 'D':                                                                             // ignore -Dxxx, forwarded by cpp, hidden
+                        break;
+                  case 'F':                                                                             // source file-name without suffix, hidden
+                  case 'y':                                                                             // dump AST on error
+                        errorp = true;
+                        break;
+                  case 'z':                                                                             // dump as codegen rather than AST
+                        codegenp = true;
+                        break;
+                        case 'Z':                                                                       // prettyprint during codegen (i.e. print unmangled names, etc.)
+                        prettycodegenp = true;
+                        break;
+                  case 'D':                                                                             // ignore -Dxxx
+                        break;
+                  case 'F':                                                                             // source file-name without suffix
                         filename = optarg;
                         break;
                   case '?':                                                                             // unknown option
+                  case '?':
                         if ( optopt ) {                                                         // short option ?
                                 cout << "Unknown option -" << (char)optopt << endl;
+                                assertf( false, "Unknown option: -%c\n", (char)optopt );
                         } else {
                                 cout << "Unknown option " << argv[optind - 1] << endl;
+                                assertf( false, "Unknown option: %s\n", argv[optind - 1] );
                         } // if
+                        goto Default;
+                  case ':':                                                                             // missing option
+                        if ( optopt ) {                                                         // short option ?
+                                cout << "Missing option for -" << (char)optopt << endl;
+                        } else {
+                                cout << "Missing option for " << argv[optind - 1] << endl;
+                        } // if
+                        goto Default;
+                  Default:
+                        #if defined(__GNUC__) && __GNUC__ >= 7
+                                __attribute__((fallthrough));
+                        #endif
                   default:
                         usage( argv );                                                          // no return
+                        abort();
                 } // switch
         } // while
 …
         list< Declaration * > decls;
         if ( genproto ) {
+        if ( noprotop ) {
                 filter( translationUnit.begin(), translationUnit.end(), back_inserter( decls ), notPrelude );
         } else {
 …
         // depending on commandline options, either generate code or dump the AST
         if ( codegenp ) {
                 CodeGen::generate( decls, out, ! genproto, prettycodegenp );
+                CodeGen::generate( decls, out, ! noprotop, prettycodegenp );
         } else {
                 printAll( decls, out );
         } // if
+        }
         deleteAll( translationUnit );
 } // dump

tests/.expect/KRfunctions.x64.txt

-              r933f32f
+              r6a9d4b4
     __attribute__ ((unused)) signed int _X10_retval_f5i_1;
+}
 signed int (*_X2f6FFi_i__iPiPi__1(signed int _X1ai_1, signed int *_X1bPi_1, signed int *_X1cPi_1))(__attribute__ ((unused)) signed int __anonymous_object0){
+signed int (*_X2f6FFi_i__iPiPi__1(signed int _X1ai_1, signed int *_X1bPi_1, signed int *_X1cPi_1))(signed int __anonymous_object0){
     __attribute__ ((unused)) signed int (*_X10_retval_f6Fi_i__1)(signed int __anonymous_object1);
+}
 …
     signed int _X1bi_2;
+    {
+        signed int *(*_tmp_cp_ret4)(signed int _X1xi_1, signed int _X1yi_1);
+        ((void)(_X1xFPi_ii__2=(((void)(_tmp_cp_ret4=_X3f10FFPi_ii__iPiPid__1(3, (&_X1ai_2), (&_X1bi_2), 3.5))) , _tmp_cp_ret4)));
+        signed int *(*_tmp_cp_ret2)(signed int _X1xi_1, signed int _X1yi_1);
+        void __cleanup_dtor4(signed int *(**_dst)(signed int _X1xi_1, signed int _X1yi_1)){
+            ((void)((*_dst)) /* ^?{} */);
+        }
+        __attribute__ ((cleanup(__destroy_Destructor))) struct __Destructor _ret_dtor4 = { 0, ((void (*)(void *__anonymous_object6))__cleanup_dtor4) };
+        void **_dtype_static_member_4 = ((void **)(&_ret_dtor4._X6objectPY12__T_generic__1));
+        ((void)(_X1xFPi_ii__2=(((void)(((void)(_tmp_cp_ret2=_X3f10FFPi_ii__iPiPid__1(3, (&_X1ai_2), (&_X1bi_2), 3.5))) , ((*_dtype_static_member_4)=((void *)(&_tmp_cp_ret2))))) , _tmp_cp_ret2)));
+    }

tests/.expect/KRfunctions.x86.txt

-              r933f32f
+              r6a9d4b4
     __attribute__ ((unused)) signed int _X10_retval_f5i_1;
+}
 signed int (*_X2f6FFi_i__iPiPi__1(signed int _X1ai_1, signed int *_X1bPi_1, signed int *_X1cPi_1))(__attribute__ ((unused)) signed int __anonymous_object0){
+signed int (*_X2f6FFi_i__iPiPi__1(signed int _X1ai_1, signed int *_X1bPi_1, signed int *_X1cPi_1))(signed int __anonymous_object0){
     __attribute__ ((unused)) signed int (*_X10_retval_f6Fi_i__1)(signed int __anonymous_object1);
+}
 …
     signed int _X1bi_2;
+    {
+        signed int *(*_tmp_cp_ret4)(signed int _X1xi_1, signed int _X1yi_1);
+        ((void)(_X1xFPi_ii__2=(((void)(_tmp_cp_ret4=_X3f10FFPi_ii__iPiPid__1(3, (&_X1ai_2), (&_X1bi_2), 3.5))) , _tmp_cp_ret4)));
+        signed int *(*_tmp_cp_ret2)(signed int _X1xi_1, signed int _X1yi_1);
+        void __cleanup_dtor4(signed int *(**_dst)(signed int _X1xi_1, signed int _X1yi_1)){
+            ((void)((*_dst)) /* ^?{} */);
+        }
+        __attribute__ ((cleanup(__destroy_Destructor))) struct __Destructor _ret_dtor4 = { 0, ((void (*)(void *__anonymous_object6))__cleanup_dtor4) };
+        void **_dtype_static_member_4 = ((void **)(&_ret_dtor4._X6objectPY12__T_generic__1));
+        ((void)(_X1xFPi_ii__2=(((void)(((void)(_tmp_cp_ret2=_X3f10FFPi_ii__iPiPid__1(3, (&_X1ai_2), (&_X1bi_2), 3.5))) , ((*_dtype_static_member_4)=((void *)(&_tmp_cp_ret2))))) , _tmp_cp_ret2)));
+    }

tests/.expect/abs.txt

-              r933f32f
+              r6a9d4b4
 signed long int         -65     abs 65
 signed long long int    -65     abs 65
 float                   -65.    abs 65.
 double                  -65.    abs 65.
 long double             -65.    abs 65.
 float _Complex          -65.-2.i        abs 65.0308
 double _Complex         -65.-2.i        abs 65.0307619515564
 long double _Complex    -65.-2.i        abs 65.0307619515564342
+float                   -65     abs 65
+double                  -65     abs 65
+long double             -65     abs 65
+float _Complex          -65-2i  abs 65.0308
+double _Complex         -65-2i  abs 65.0307619515564
+long double _Complex    -65-2i  abs 65.0307619515564342

tests/.expect/ato.txt

r933f32f	r6a9d4b4
22	22	-123.456789012345679 -123.45678901234567890123456789
23	23	-123.456-123.456i -123.456-123.456i
24		0~~.+0.~~i 2 3
	24	0+0i 2 3
25	25	-123.456789012346+123.456789012346i -123.4567890123456+123.4567890123456i
26	26	123.456789012345679-123.456789012345679i 123.45678901234567890123456789-123.45678901234567890123456789i

tests/.expect/attributes.x64.txt

r933f32f	r6a9d4b4
640	640	}
641	641	__attribute__ ((unused,used,unused)) signed int (*_X2f4FFi_i____1())(signed int __anonymous_object1);
642		__attribute__ ((unused,unused)) signed int (*_X2f4FFi_i____1())(~~__attribute__ ((unused))~~ signed int __anonymous_object2){
	642	__attribute__ ((unused,unused)) signed int (*_X2f4FFi_i____1())(signed int __anonymous_object2){
643	643	__attribute__ ((unused)) signed int (*_X10_retval_f4Fi_i__1)(signed int __anonymous_object3);
644	644	}

tests/.expect/attributes.x86.txt

r933f32f	r6a9d4b4
640	640	}
641	641	__attribute__ ((unused,used,unused)) signed int (*_X2f4FFi_i____1())(signed int __anonymous_object1);
642		__attribute__ ((unused,unused)) signed int (*_X2f4FFi_i____1())(~~__attribute__ ((unused))~~ signed int __anonymous_object2){
	642	__attribute__ ((unused,unused)) signed int (*_X2f4FFi_i____1())(signed int __anonymous_object2){
643	643	__attribute__ ((unused)) signed int (*_X10_retval_f4Fi_i__1)(signed int __anonymous_object3);
644	644	}

tests/.expect/castError.txt

-              r933f32f
+              r6a9d4b4
 castError.cfa:21:1 error: Cannot choose between 3 alternatives for expression
 Explicit Cast of:
+castError.cfa:7:1 error: Cannot choose between 3 alternatives for expression
+Cast of:
   Name: f
 ... to:
   char Alternatives are:
 Cost ( 1, 0, 0, 0, 0, 0, 0 ): Explicit Cast of:
+Cost ( 1, 0, 0, 0, 0, 0 ): Cast of:
      Variable Expression: f: function
        accepting unspecified arguments
 …
  Environment:
 Cost ( 1, 0, 0, 0, 0, 0, 0 ): Explicit Cast of:
+Cost ( 1, 0, 0, 0, 0, 0 ): Cast of:
      Variable Expression: f: double
    ... to:
 …
  Environment:
 Cost ( 1, 0, 0, 0, 0, 0, 0 ): Explicit Cast of:
+Cost ( 1, 0, 0, 0, 0, 0 ): Cast of:
      Variable Expression: f: signed int
    ... to:
 …
-castError.cfa:26:1 error: Cannot choose between 2 alternatives for expression
-Generated Cast of:
-  Comma Expression:
-    constant expression (3 3: signed int)
-    Name: v
-... to: nothing Alternatives are:
-Cost ( 0, 0, 2, 0, 0, 0, 0 ): Generated Cast of:
-     Comma Expression:
-       constant expression (3 3: signed int)
-       Variable Expression: v: unsigned char
-   ... to: nothing
- (types:
-   void
+ )
- Environment:
-Cost ( 0, 0, 2, 0, 0, 0, 0 ): Generated Cast of:
-     Comma Expression:
-       constant expression (3 3: signed int)
-       Variable Expression: v: signed short int
-   ... to: nothing
- (types:
-   void
+ )
- Environment:

tests/.expect/completeTypeError.txt

-              r933f32f
+              r6a9d4b4
+completeTypeError.cfa:34:1 error: Cannot choose between 2 alternatives for expression
+Generated Cast of:
+  Applying untyped:
+    Name: *?
+  ...to:
+    Name: x
+completeTypeError.cfa:33:1 error: No reasonable alternatives for expression Applying untyped:
+  Name: *?
+...to:
+  Name: v
+... to: nothing Alternatives are:
+Cost ( 0, 1, 2, 0, 1, -1, 0 ): Generated Cast of:
+     Application of
+       Variable Expression: *?: forall
+         DT: object type
+         function
+       ... with parameters
+         intrinsic pointer to instance of type DT (not function type)
+       ... returning
+         _retval__operator_deref: reference to instance of type DT (not function type)
+         ... with attributes:
+           Attribute with name: unused
+     ... to arguments
+       Variable Expression: x: pointer to instance of struct A with body 0
+   ... to: nothing
+ (types:
+   void
+ )
+ Environment:( _80_4_DT ) -> instance of struct A with body 0 (no widening)
+Cost ( 0, 1, 2, 0, 1, -1, 0 ): Generated Cast of:
+     Application of
+       Variable Expression: *?: forall
+         DT: object type
+         function
+       ... with parameters
+         intrinsic pointer to instance of type DT (not function type)
+       ... returning
+         _retval__operator_deref: reference to instance of type DT (not function type)
+         ... with attributes:
+           Attribute with name: unused
+     ... to arguments
+       Variable Expression: x: pointer to instance of struct B with body 1
+   ... to: nothing
+ (types:
+   void
+ )
+ Environment:( _80_4_DT ) -> instance of struct B with body 1 (no widening)
+completeTypeError.cfa:34:1 error: No reasonable alternatives for expression Applying untyped:
+  Name: *?
+...to:
+  Name: y
 completeTypeError.cfa:35:1 error: No reasonable alternatives for expression Applying untyped:
 …
   Name: v
 completeTypeError.cfa:59:1 error: No reasonable alternatives for expression Applying untyped:
+completeTypeError.cfa:58:1 error: No reasonable alternatives for expression Applying untyped:
   Name: baz
 ...to:
   Name: y
 completeTypeError.cfa:60:1 error: No reasonable alternatives for expression Applying untyped:
+completeTypeError.cfa:59:1 error: No reasonable alternatives for expression Applying untyped:
   Name: quux
 ...to:
   Name: y
+completeTypeError.cfa:72:1 error: No alternatives with satisfiable assertions for Applying untyped:
+completeTypeError.cfa:60:1 error: No reasonable alternatives for expression Applying untyped:
+  Name: *?
+...to:
+  Name: y
+completeTypeError.cfa:72:1 error: No resolvable alternatives for expression Applying untyped:
   Name: baz
 ...to:
   Name: z
    Unsatisfiable alternative:
 Cost ( 0, 1, 0, 0, 1, -5, 0 ): Application of
          Variable Expression: baz: forall
            T: sized object type
            ... with assertions
              ?=?: pointer to function
              ... with parameters
                reference to instance of type T (not function type)
                instance of type T (not function type)
              ... returning
                _retval__operator_assign: instance of type T (not function type)
                ... with attributes:
                  Attribute with name: unused
+Alternatives with failing assertions are:
+Cost ( 0, 1, 0, 1, -5, 0 ): Application of
+     Variable Expression: baz: forall
+       T: sized object type
+       ... with assertions
+         ?=?: pointer to function
+         ... with parameters
+           reference to instance of type T (not function type)
+           instance of type T (not function type)
+         ... returning
+           _retval__operator_assign: instance of type T (not function type)
+           ... with attributes:
+             Attribute with name: unused
              ?{}: pointer to function
              ... with parameters
                reference to instance of type T (not function type)
              ... returning nothing
+         ?{}: pointer to function
+         ... with parameters
+           reference to instance of type T (not function type)
+         ... returning nothing
              ?{}: pointer to function
              ... with parameters
                reference to instance of type T (not function type)
                instance of type T (not function type)
              ... returning nothing
+         ?{}: pointer to function
+         ... with parameters
+           reference to instance of type T (not function type)
+           instance of type T (not function type)
+         ... returning nothing
              ^?{}: pointer to function
              ... with parameters
                reference to instance of type T (not function type)
              ... returning nothing
+         ^?{}: pointer to function
+         ... with parameters
+           reference to instance of type T (not function type)
+         ... returning nothing
            function
          ... with parameters
            pointer to instance of type T (not function type)
          ... returning nothing
+       function
+     ... with parameters
+       pointer to instance of type T (not function type)
+     ... returning nothing
        ... to arguments
          Variable Expression: z: pointer to instance of type T (not function type)
+   ... to arguments
+     Variable Expression: z: pointer to instance of type T (not function type)
+     (types:
+       void
+     )
+     Environment:( _99_0_T ) -> instance of type T (not function type) (no widening)
+   Could not satisfy assertion:
+?=?: pointer to function
+     ... with parameters
+       reference to instance of type _99_0_T (not function type)
+       instance of type _99_0_T (not function type)
+     ... returning
+       _retval__operator_assign: instance of type _99_0_T (not function type)
+       ... with attributes:
+         Attribute with name: unused
+ (types:
+   void
+ )
+ Environment:( _73_0_T ) -> instance of type T (not function type) (no widening)

tests/.expect/complex.txt

r933f32f	r6a9d4b4
1	1	x:3+2i y:4+5i z:7+7i
2		x:3~~.+2.i y:4.+5.i z:7.+7.~~i
	2	x:3+2i y:4+5i z:7+7i
3	3	x:2.1+1.3i y:3.2+4.5i z:5.3+5.8i
4	4	x:2.1+1.3i y:3.2+4.5i z:5.3+5.8i

tests/.expect/declarationSpecifier.x64.txt

r933f32f	r6a9d4b4
1122	1122	__attribute__ ((unused)) signed int _X12_retval_maini_1;
1123	1123	{
	1124	((void)(_X12_retval_maini_1=((signed int )0)) /* ?{} */);
	1125	}
	1126
	1127	return _X12_retval_maini_1;
	1128	{
1124	1129	((void)(_X12_retval_maini_1=0) /* ?{} */);
1125	1130	}
…	…
1132	1137	__attribute__ ((unused)) signed int _X12_retval_maini_1;
1133	1138	{
1134		signed int _tmp_cp_ret4;
1135		((void)(_X12_retval_maini_1=(((void)(_tmp_cp_ret4=invoke_main(_X4argci_1, _X4argvPPc_1, _X4envpPPc_1))) , _tmp_cp_ret4)) /* ?{} */);
	1139	signed int _tmp_cp_ret2;
	1140	__attribute__ ((cleanup(__destroy_Destructor))) struct __Destructor _ret_dtor4 = { 0, ((void ()(void __anonymous_object0))_X11_destructorFv_i_intrinsic___1) };
	1141	void _dtype_static_member_4 = ((void )(&_ret_dtor4._X6objectPY12__T_generic__1));
	1142	((void)(_X12_retval_maini_1=(((void)(((void)(_tmp_cp_ret2=invoke_main(_X4argci_1, _X4argvPPc_1, _X4envpPPc_1))) , ((_dtype_static_member_4)=((void )(&_tmp_cp_ret2))))) , _tmp_cp_ret2)) /* ?{} */);
1136	1143	}
1137	1144

tests/.expect/declarationSpecifier.x86.txt

r933f32f	r6a9d4b4
1122	1122	__attribute__ ((unused)) signed int _X12_retval_maini_1;
1123	1123	{
	1124	((void)(_X12_retval_maini_1=((signed int )0)) /* ?{} */);
	1125	}
	1126
	1127	return _X12_retval_maini_1;
	1128	{
1124	1129	((void)(_X12_retval_maini_1=0) /* ?{} */);
1125	1130	}
…	…
1132	1137	__attribute__ ((unused)) signed int _X12_retval_maini_1;
1133	1138	{
1134		signed int _tmp_cp_ret4;
1135		((void)(_X12_retval_maini_1=(((void)(_tmp_cp_ret4=invoke_main(_X4argci_1, _X4argvPPc_1, _X4envpPPc_1))) , _tmp_cp_ret4)) /* ?{} */);
	1139	signed int _tmp_cp_ret2;
	1140	__attribute__ ((cleanup(__destroy_Destructor))) struct __Destructor _ret_dtor4 = { 0, ((void ()(void __anonymous_object0))_X11_destructorFv_i_intrinsic___1) };
	1141	void _dtype_static_member_4 = ((void )(&_ret_dtor4._X6objectPY12__T_generic__1));
	1142	((void)(_X12_retval_maini_1=(((void)(((void)(_tmp_cp_ret2=invoke_main(_X4argci_1, _X4argvPPc_1, _X4envpPPc_1))) , ((_dtype_static_member_4)=((void )(&_tmp_cp_ret2))))) , _tmp_cp_ret2)) /* ?{} */);
1136	1143	}
1137	1144

tests/.expect/extension.x64.txt

r933f32f	r6a9d4b4
457	457
458	458	{
459		signed int _tmp_cp_ret4;
460		((void)(((void)(_tmp_cp_ret4=__extension__ _X4fredFi_i__1(3))) , _tmp_cp_ret4));
	459	signed int _tmp_cp_ret2;
	460	__attribute__ ((cleanup(__destroy_Destructor))) struct __Destructor _ret_dtor4 = { 0, ((void ()(void __anonymous_object0))_X11_destructorFv_i_intrinsic___1) };
	461	void _dtype_static_member_4 = ((void )(&_ret_dtor4._X6objectPY12__T_generic__1));
	462	((void)(((void)(((void)(_tmp_cp_ret2=__extension__ _X4fredFi_i__1(3))) , ((_dtype_static_member_4)=((void )(&_tmp_cp_ret2))))) , _tmp_cp_ret2));
461	463	}
462	464

tests/.expect/extension.x86.txt

r933f32f	r6a9d4b4
457	457
458	458	{
459		signed int _tmp_cp_ret4;
460		((void)(((void)(_tmp_cp_ret4=__extension__ _X4fredFi_i__1(3))) , _tmp_cp_ret4));
	459	signed int _tmp_cp_ret2;
	460	__attribute__ ((cleanup(__destroy_Destructor))) struct __Destructor _ret_dtor4 = { 0, ((void ()(void __anonymous_object0))_X11_destructorFv_i_intrinsic___1) };
	461	void _dtype_static_member_4 = ((void )(&_ret_dtor4._X6objectPY12__T_generic__1));
	462	((void)(((void)(((void)(_tmp_cp_ret2=__extension__ _X4fredFi_i__1(3))) , ((_dtype_static_member_4)=((void )(&_tmp_cp_ret2))))) , _tmp_cp_ret2));
461	463	}
462	464

tests/.expect/functions.x64.txt

r933f32f	r6a9d4b4
1	1	void _X1hFv___1(void){
2	2	}
3		signed int _X1fFi_Fi__Fi_i_Fi__Fi_i_Fv____1(__attribute__ ((unused)) signed int (__anonymous_object0)(void), __attribute__ ((unused)) signed int (__anonymous_object1)(signed int __anonymous_object2), __attribute__ ((unused)) signed int (__anonymous_object3)(void), __attribute__ ((unused)) signed int (__anonymous_object4)(signed int __anonymous_object5), void (*_X1gFv___1)(void)){
	3	signed int _X1fFi_Fi__Fi_i_Fi__Fi_i_Fv____1(signed int (__anonymous_object0)(void), signed int (__anonymous_object1)(signed int __anonymous_object2), signed int (__anonymous_object3)(void), signed int (__anonymous_object4)(signed int __anonymous_object5), void (*_X1gFv___1)(void)){
4	4	__attribute__ ((unused)) signed int _X9_retval_fi_1;
5	5	{
…	…
99	99	__attribute__ ((unused)) signed int _X9_retval_fi_1;
100	100	}
101		signed int _X1fFi_i__1(~~__attribute__ ((unused))~~ signed int __anonymous_object7){
	101	signed int _X1fFi_i__1(signed int __anonymous_object7){
102	102	__attribute__ ((unused)) signed int _X9_retval_fi_1;
103	103	}
…	…
130	130	__attribute__ ((unused)) struct _conc__tuple2_0 _X9_retval_fT2ii_1 = { };
131	131	}
132		struct _conc__tuple2_0 _X1fFT2ii_ii__1(~~__attribute__ ((unused))~~ signed int __anonymous_object9, signed int _X1xi_1){
	132	struct _conc__tuple2_0 _X1fFT2ii_ii__1(signed int __anonymous_object9, signed int _X1xi_1){
133	133	__attribute__ ((unused)) struct _conc__tuple2_0 _X9_retval_fT2ii_1 = { };
134	134	}
…	…
167	167	__attribute__ ((unused)) struct _conc__tuple3_1 _X9_retval_fT3iii_1 = { };
168	168	}
169		struct _conc__tuple3_1 _X1fFT3iii_iii__1(~~__attribute__ ((unused)) signed int __anonymous_object12, signed int _X1xi_1, __attribute__ ((unused))~~ signed int __anonymous_object13){
	169	struct _conc__tuple3_1 _X1fFT3iii_iii__1(signed int __anonymous_object12, signed int _X1xi_1, signed int __anonymous_object13){
170	170	__attribute__ ((unused)) struct _conc__tuple3_1 _X9_retval_fT3iii_1 = { };
171	171	}
…	…
180	180	__attribute__ ((unused)) struct _conc__tuple3_2 _X9_retval_fT3iiPi_1 = { };
181	181	}
182		struct _conc__tuple3_2 _X1fFT3iiPi_iiPi__1(~~__attribute__ ((unused))~~ signed int __anonymous_object15, signed int _X1xi_1, signed int *_X1yPi_1){
	182	struct _conc__tuple3_2 _X1fFT3iiPi_iiPi__1(signed int __anonymous_object15, signed int _X1xi_1, signed int *_X1yPi_1){
183	183	__attribute__ ((unused)) struct _conc__tuple3_2 _X9_retval_fT3iiPi_1 = { };
184	184	}
…	…
190	190	const double _X3fooFd___1(void);
191	191	const double _X3fooFd_i__1(signed int __anonymous_object19);
192		const double _X3fooFd_d__1(~~__attribute__ ((unused))~~ double __anonymous_object20){
	192	const double _X3fooFd_d__1(double __anonymous_object20){
193	193	__attribute__ ((unused)) const double _X11_retval_fooKd_1;
194	194	{
…	…
242	242
243	243	}
244		struct S _X3rtnFS1S_i__1(~~__attribute__ ((unused))~~ signed int __anonymous_object21){
	244	struct S _X3rtnFS1S_i__1(signed int __anonymous_object21){
245	245	__attribute__ ((unused)) struct S _X11_retval_rtnS1S_1;
246	246	}
247		signed int _X1fFi_Fi_ii_Fi_i___1(~~__attribute__ ((unused)) signed int (__anonymous_object22)(signed int __anonymous_object23, signed int _X1pi_1), __attribute__ ((unused))~~ signed int (__anonymous_object24)(signed int __anonymous_object25)){
	247	signed int _X1fFi_Fi_ii_Fi_i___1(signed int (__anonymous_object22)(signed int __anonymous_object23, signed int _X1pi_1), signed int (__anonymous_object24)(signed int __anonymous_object25)){
248	248	__attribute__ ((unused)) signed int _X9_retval_fi_1;
249	249	signed int ((_X2pcPA0A0PA0A0i_2)[][((unsigned long int )10)])[][((unsigned long int )3)];
…	…
271	271	}
272	272	signed int _X1fFi_Fi__FPi__FPPi__FPKPi__FPKPi__PiPiPPiPPiPPPiPPPiPPKPiPPKPiPKPKPiPKPKPi__1(signed int (__anonymous_object27)(), signed int (__anonymous_object28)(), signed int (__anonymous_object29)(), signed int const (__anonymous_object30)(), signed int const const (__anonymous_object31)(), signed int __anonymous_object32, signed int __anonymous_object33[((unsigned long int )10)], signed int __anonymous_object34, signed int __anonymous_object35[((unsigned long int )10)], signed int *__anonymous_object36, signed int __anonymous_object37[((unsigned long int )10)], signed int const __anonymous_object38, signed int const __anonymous_object39[((unsigned long int )10)], signed int const const __anonymous_object40, signed int const const __anonymous_object41[((unsigned long int )10)]);
273		signed int _X1fFi_Fi__FPi__FPPi__FPKPi__FPKPi__PiPiPPiPPiPPPiPPPiPPKPiPPKPiPKPKPiPKPKPi__1(__attribute__ ((unused)) signed int (__anonymous_object42)(), __attribute__ ((unused)) signed int (__anonymous_object43)(), __attribute__ ((unused)) signed int (__anonymous_object44)(), __attribute__ ((unused)) signed int const (__anonymous_object45)(), __attribute__ ((unused)) signed int const const (__anonymous_object46)(), __attribute__ ((unused)) signed int __anonymous_object47, __attribute__ ((unused)) signed int __anonymous_object48[((unsigned long int )10)], __attribute__ ((unused)) signed int __anonymous_object49, __attribute__ ((unused)) signed int __anonymous_object50[((unsigned long int )10)], __attribute__ ((unused)) signed int *__anonymous_object51, __attribute__ ((unused)) signed int __anonymous_object52[((unsigned long int )10)], __attribute__ ((unused)) signed int const __anonymous_object53, __attribute__ ((unused)) signed int const __anonymous_object54[((unsigned long int )10)], __attribute__ ((unused)) signed int const const __anonymous_object55, __attribute__ ((unused)) signed int const const __anonymous_object56[((unsigned long int )10)]){
	273	signed int _X1fFi_Fi__FPi__FPPi__FPKPi__FPKPi__PiPiPPiPPiPPPiPPPiPPKPiPPKPiPKPKPiPKPKPi__1(signed int (__anonymous_object42)(), signed int (__anonymous_object43)(), signed int (__anonymous_object44)(), signed int const (__anonymous_object45)(), signed int const const (__anonymous_object46)(), signed int __anonymous_object47, signed int __anonymous_object48[((unsigned long int )10)], signed int __anonymous_object49, signed int __anonymous_object50[((unsigned long int )10)], signed int *__anonymous_object51, signed int __anonymous_object52[((unsigned long int )10)], signed int const __anonymous_object53, signed int const __anonymous_object54[((unsigned long int )10)], signed int const const __anonymous_object55, signed int const const __anonymous_object56[((unsigned long int )10)]){
274	274	__attribute__ ((unused)) signed int _X9_retval_fi_1;
275	275	}

tests/.expect/functions.x86.txt

r933f32f	r6a9d4b4
1	1	void _X1hFv___1(void){
2	2	}
3		signed int _X1fFi_Fi__Fi_i_Fi__Fi_i_Fv____1(__attribute__ ((unused)) signed int (__anonymous_object0)(void), __attribute__ ((unused)) signed int (__anonymous_object1)(signed int __anonymous_object2), __attribute__ ((unused)) signed int (__anonymous_object3)(void), __attribute__ ((unused)) signed int (__anonymous_object4)(signed int __anonymous_object5), void (*_X1gFv___1)(void)){
	3	signed int _X1fFi_Fi__Fi_i_Fi__Fi_i_Fv____1(signed int (__anonymous_object0)(void), signed int (__anonymous_object1)(signed int __anonymous_object2), signed int (__anonymous_object3)(void), signed int (__anonymous_object4)(signed int __anonymous_object5), void (*_X1gFv___1)(void)){
4	4	__attribute__ ((unused)) signed int _X9_retval_fi_1;
5	5	{
…	…
99	99	__attribute__ ((unused)) signed int _X9_retval_fi_1;
100	100	}
101		signed int _X1fFi_i__1(~~__attribute__ ((unused))~~ signed int __anonymous_object7){
	101	signed int _X1fFi_i__1(signed int __anonymous_object7){
102	102	__attribute__ ((unused)) signed int _X9_retval_fi_1;
103	103	}
…	…
130	130	__attribute__ ((unused)) struct _conc__tuple2_0 _X9_retval_fT2ii_1 = { };
131	131	}
132		struct _conc__tuple2_0 _X1fFT2ii_ii__1(~~__attribute__ ((unused))~~ signed int __anonymous_object9, signed int _X1xi_1){
	132	struct _conc__tuple2_0 _X1fFT2ii_ii__1(signed int __anonymous_object9, signed int _X1xi_1){
133	133	__attribute__ ((unused)) struct _conc__tuple2_0 _X9_retval_fT2ii_1 = { };
134	134	}
…	…
167	167	__attribute__ ((unused)) struct _conc__tuple3_1 _X9_retval_fT3iii_1 = { };
168	168	}
169		struct _conc__tuple3_1 _X1fFT3iii_iii__1(~~__attribute__ ((unused)) signed int __anonymous_object12, signed int _X1xi_1, __attribute__ ((unused))~~ signed int __anonymous_object13){
	169	struct _conc__tuple3_1 _X1fFT3iii_iii__1(signed int __anonymous_object12, signed int _X1xi_1, signed int __anonymous_object13){
170	170	__attribute__ ((unused)) struct _conc__tuple3_1 _X9_retval_fT3iii_1 = { };
171	171	}
…	…
180	180	__attribute__ ((unused)) struct _conc__tuple3_2 _X9_retval_fT3iiPi_1 = { };
181	181	}
182		struct _conc__tuple3_2 _X1fFT3iiPi_iiPi__1(~~__attribute__ ((unused))~~ signed int __anonymous_object15, signed int _X1xi_1, signed int *_X1yPi_1){
	182	struct _conc__tuple3_2 _X1fFT3iiPi_iiPi__1(signed int __anonymous_object15, signed int _X1xi_1, signed int *_X1yPi_1){
183	183	__attribute__ ((unused)) struct _conc__tuple3_2 _X9_retval_fT3iiPi_1 = { };
184	184	}
…	…
190	190	const double _X3fooFd___1(void);
191	191	const double _X3fooFd_i__1(signed int __anonymous_object19);
192		const double _X3fooFd_d__1(~~__attribute__ ((unused))~~ double __anonymous_object20){
	192	const double _X3fooFd_d__1(double __anonymous_object20){
193	193	__attribute__ ((unused)) const double _X11_retval_fooKd_1;
194	194	{
…	…
242	242
243	243	}
244		struct S _X3rtnFS1S_i__1(~~__attribute__ ((unused))~~ signed int __anonymous_object21){
	244	struct S _X3rtnFS1S_i__1(signed int __anonymous_object21){
245	245	__attribute__ ((unused)) struct S _X11_retval_rtnS1S_1;
246	246	}
247		signed int _X1fFi_Fi_ii_Fi_i___1(~~__attribute__ ((unused)) signed int (__anonymous_object22)(signed int __anonymous_object23, signed int _X1pi_1), __attribute__ ((unused))~~ signed int (__anonymous_object24)(signed int __anonymous_object25)){
	247	signed int _X1fFi_Fi_ii_Fi_i___1(signed int (__anonymous_object22)(signed int __anonymous_object23, signed int _X1pi_1), signed int (__anonymous_object24)(signed int __anonymous_object25)){
248	248	__attribute__ ((unused)) signed int _X9_retval_fi_1;
249	249	signed int ((_X2pcPA0A0PA0A0i_2)[][((unsigned int )10)])[][((unsigned int )3)];
…	…
271	271	}
272	272	signed int _X1fFi_Fi__FPi__FPPi__FPKPi__FPKPi__PiPiPPiPPiPPPiPPPiPPKPiPPKPiPKPKPiPKPKPi__1(signed int (__anonymous_object27)(), signed int (__anonymous_object28)(), signed int (__anonymous_object29)(), signed int const (__anonymous_object30)(), signed int const const (__anonymous_object31)(), signed int __anonymous_object32, signed int __anonymous_object33[((unsigned int )10)], signed int __anonymous_object34, signed int __anonymous_object35[((unsigned int )10)], signed int *__anonymous_object36, signed int __anonymous_object37[((unsigned int )10)], signed int const __anonymous_object38, signed int const __anonymous_object39[((unsigned int )10)], signed int const const __anonymous_object40, signed int const const __anonymous_object41[((unsigned int )10)]);
273		signed int _X1fFi_Fi__FPi__FPPi__FPKPi__FPKPi__PiPiPPiPPiPPPiPPPiPPKPiPPKPiPKPKPiPKPKPi__1(__attribute__ ((unused)) signed int (__anonymous_object42)(), __attribute__ ((unused)) signed int (__anonymous_object43)(), __attribute__ ((unused)) signed int (__anonymous_object44)(), __attribute__ ((unused)) signed int const (__anonymous_object45)(), __attribute__ ((unused)) signed int const const (__anonymous_object46)(), __attribute__ ((unused)) signed int __anonymous_object47, __attribute__ ((unused)) signed int __anonymous_object48[((unsigned int )10)], __attribute__ ((unused)) signed int __anonymous_object49, __attribute__ ((unused)) signed int __anonymous_object50[((unsigned int )10)], __attribute__ ((unused)) signed int *__anonymous_object51, __attribute__ ((unused)) signed int __anonymous_object52[((unsigned int )10)], __attribute__ ((unused)) signed int const __anonymous_object53, __attribute__ ((unused)) signed int const __anonymous_object54[((unsigned int )10)], __attribute__ ((unused)) signed int const const __anonymous_object55, __attribute__ ((unused)) signed int const const __anonymous_object56[((unsigned int )10)]){
	273	signed int _X1fFi_Fi__FPi__FPPi__FPKPi__FPKPi__PiPiPPiPPiPPPiPPPiPPKPiPPKPiPKPKPiPKPKPi__1(signed int (__anonymous_object42)(), signed int (__anonymous_object43)(), signed int (__anonymous_object44)(), signed int const (__anonymous_object45)(), signed int const const (__anonymous_object46)(), signed int __anonymous_object47, signed int __anonymous_object48[((unsigned int )10)], signed int __anonymous_object49, signed int __anonymous_object50[((unsigned int )10)], signed int *__anonymous_object51, signed int __anonymous_object52[((unsigned int )10)], signed int const __anonymous_object53, signed int const __anonymous_object54[((unsigned int )10)], signed int const const __anonymous_object55, signed int const const __anonymous_object56[((unsigned int )10)]){
274	274	__attribute__ ((unused)) signed int _X9_retval_fi_1;
275	275	}

tests/.expect/gccExtensions.x64.txt

r933f32f	r6a9d4b4
292	292	signed int _X2m3A0A0i_2[((unsigned long int )10)][((unsigned long int )10)];
293	293	{
294		((void)(_X12_retval_maini_1=0) /* ?{} */);
	294	((void)(_X12_retval_maini_1=((signed int )0)) /* ?{} */);
295	295	}
296	296
…	…
307	307	__attribute__ ((unused)) signed int _X12_retval_maini_1;
308	308	{
309		signed int _tmp_cp_ret4;
310		((void)(_X12_retval_maini_1=(((void)(_tmp_cp_ret4=invoke_main(_X4argci_1, _X4argvPPc_1, _X4envpPPc_1))) , _tmp_cp_ret4)) /* ?{} */);
	309	signed int _tmp_cp_ret2;
	310	__attribute__ ((cleanup(__destroy_Destructor))) struct __Destructor _ret_dtor4 = { 0, ((void ()(void __anonymous_object0))_X11_destructorFv_i_intrinsic___1) };
	311	void _dtype_static_member_4 = ((void )(&_ret_dtor4._X6objectPY12__T_generic__1));
	312	((void)(_X12_retval_maini_1=(((void)(((void)(_tmp_cp_ret2=invoke_main(_X4argci_1, _X4argvPPc_1, _X4envpPPc_1))) , ((_dtype_static_member_4)=((void )(&_tmp_cp_ret2))))) , _tmp_cp_ret2)) /* ?{} */);
311	313	}
312	314

tests/.expect/gccExtensions.x86.txt

r933f32f	r6a9d4b4
292	292	signed int _X2m3A0A0i_2[((unsigned int )10)][((unsigned int )10)];
293	293	{
294		((void)(_X12_retval_maini_1=0) /* ?{} */);
	294	((void)(_X12_retval_maini_1=((signed int )0)) /* ?{} */);
295	295	}
296	296
…	…
307	307	__attribute__ ((unused)) signed int _X12_retval_maini_1;
308	308	{
309		signed int _tmp_cp_ret4;
310		((void)(_X12_retval_maini_1=(((void)(_tmp_cp_ret4=invoke_main(_X4argci_1, _X4argvPPc_1, _X4envpPPc_1))) , _tmp_cp_ret4)) /* ?{} */);
	309	signed int _tmp_cp_ret2;
	310	__attribute__ ((cleanup(__destroy_Destructor))) struct __Destructor _ret_dtor4 = { 0, ((void ()(void __anonymous_object0))_X11_destructorFv_i_intrinsic___1) };
	311	void _dtype_static_member_4 = ((void )(&_ret_dtor4._X6objectPY12__T_generic__1));
	312	((void)(_X12_retval_maini_1=(((void)(((void)(_tmp_cp_ret2=invoke_main(_X4argci_1, _X4argvPPc_1, _X4envpPPc_1))) , ((_dtype_static_member_4)=((void )(&_tmp_cp_ret2))))) , _tmp_cp_ret2)) /* ?{} */);
311	313	}
312	314

tests/.expect/identity.txt

-              r933f32f
+              r6a9d4b4
 double                  4.1
 long double             4.1
 float _Complex          -4.1-2.i
 double _Complex         -4.1-2.i
 long double _Complex    -4.1-2.i
+float _Complex          -4.1-2i
+double _Complex         -4.1-2i
+long double _Complex    -4.1-2i

tests/.expect/io1.txt

-              r933f32f
+              r6a9d4b4
 6 28 0 7 1 2
 1 2 3
+2 3
 opening delimiters

tests/.expect/loopctrl.txt

-              r933f32f
+              r6a9d4b4
 8 6 4 2
-2 3 4 5 6 7 8 9 10
-9 8 7 6 5 4 3 2 1 0
-4 6 8 10
-.1 3.8 5.5 7.2 8.9
-8 6 4 2 0
-.1 10.4 8.7 7. 5.3 3.6
 N N N N N N N N N N
 …
 9 8 7 6 5 4 3 2 1
 6 9
 (0 0)(1 1)(2 2)(3 3)(4 4)(5 5)(6 6)(7 7)(8 8)(9 9)
 …
 (10 10)(9 9)(8 8)(7 7)(6 6)(5 5)(4 4)(3 3)(2 2)(1 1)(0 0)
 (10 10)(9 9)(8 8)(7 7)(6 6)(5 5)(4 4)(3 3)(2 2)(1 1)(0 0)
--5 1 -4 2 -3 3 -2 4 -1 5 0 6 1 7 2 8 3 9 4
--5 1 -6 2 -7 3 -8 4 -9 5 -10 6 -11 7 -12 8 -13 9 -14
--5 1 -3 2 -1 3 1 4 3 5 5 6 7 7 9 8 11 9 13
--5 1 -7 2 -9 3 -11 4 -13 5 -15 6 -17 7 -19 8 -21 9 -23
--5 1 -4 2 -3 3 -2 4 -1 5 0 6 1 7 2 8 3 9 4
--5 1 -6 2 -7 3 -8 4 -9 5 -10 6 -11 7 -12 8 -13 9 -14
--5 1 -3 2 -1 3 1 4 3 5 5 6 7 7 9 8 11 9 13
--5 1 -7 2 -9 3 -11 4 -13 5 -15 6 -17 7 -19 8 -21 9 -23
--5 1.5 1 -7 2.5 2 -9 3.5 3 -11 4.5 4 -13 5.5 5 -15 6.5 6 -17 7.5 7 -19 8.5 8 -21 9.5 9 -23 10.5
--5 1.5 1 -7 2.5 2 -9 3.5 3 -11 4.5 4 -13 5.5 5 -15 6.5 6 -17 7.5 7 -19 8.5 8 -21 9.5 9 -23 10.5
--5 1.5 1 -7 2.5 2 -9 3.5 3 -11 4.5 4 -13 5.5 5 -15 6.5 6 -17 7.5 7 -19 8.5 8 -21 9.5 9 -23 10.5

tests/.expect/math1.txt

-              r933f32f
+              r6a9d4b4
 fmod:1. 1. 1. 1. 1. 1.
 remainder:-1. -1. -1.
+fmod:1 1 1 1 1 1
+remainder:-1 -1 -1
 remquo:7 0.0999999 7 0.1 7 0.0999999999999999999
 div:7., 0.2 7., 0.2 7., 0.2
 fma:-2. -2. -2.
 fdim:2. 2. 2.
+div:7, 0.2 7, 0.2 7, 0.2
+fma:-2 -2 -2
+fdim:2 2 2
 nan:nan nan nan
 exp:2.71828 2.71828182845905 2.71828182845904524 1.46869+2.28736i 1.46869393991589+2.28735528717884i 1.46869393991588516+2.28735528717884239i
 exp2:2. 2. 2.
+exp2:2 2 2
 expm1:1.71828 1.71828182845905 1.71828182845904524
+pow:1. 1. 1. 0.273957+0.583701i 0.273957253830121+0.583700758758615i -0.638110484918098871+0.705394566961838155i
+\ 2 = 256
+256 64 -64 0 0
+.015625 -0.015625 18.3791736799526 0.264715-1.1922i
+0 18.3791736799526 0.264715-1.1922i
+16
+pow:1 1 1 0.273957+0.583701i 0.273957253830121+0.583700758758615i -0.638110484918098871+0.705394566961838155i
+\ 16 256
+\ 912673 256 64 -64 0.015625 -0.015625 18.3791736799526 0.264715-1.1922i

tests/.expect/math2.txt

-              r933f32f
+              r6a9d4b4
 log:0. 0. 0. 0.346574+0.785398i 0.346573590279973+0.785398163397448i 0.346573590279972655+0.78539816339744831i
 log2:3. 3. 3.
 log10:2. 2. 2.
+log:0 0 0 0.346574+0.785398i 0.346573590279973+0.785398163397448i 0.346573590279972655+0.78539816339744831i
+log2:3 3 3
+log10:2 2 2
 log1p:0.693147 0.693147180559945 0.693147180559945309
 ilogb:0 0 0
 logb:3. 3. 3.
 sqrt:1. 1. 1. 1.09868+0.45509i 1.09868411346781+0.455089860562227i 1.09868411346780997+0.455089860562227341i
 cbrt:3. 3. 3.
+logb:3 3 3
+sqrt:1 1 1 1.09868+0.45509i 1.09868411346781+0.455089860562227i 1.09868411346780997+0.455089860562227341i
+cbrt:3 3 3
 hypot:1.41421 1.4142135623731 1.41421356237309505
 sin:0.841471 0.841470984807897 0.841470984807896507 1.29846+0.634964i 1.29845758141598+0.634963914784736i 1.29845758141597729+0.634963914784736108i
 …
 tan:1.55741 1.5574077246549 1.55740772465490223 0.271753+1.08392i 0.271752585319512+1.08392332733869i 0.271752585319511717+1.08392332733869454i
 asin:1.5708 1.5707963267949 1.57079632679489662 0.666239+1.06128i 0.666239432492515+1.06127506190504i 0.666239432492515255+1.06127506190503565i
 acos:0. 0. 0. 0.904557-1.06128i 0.904556894302381-1.06127506190504i 0.904556894302381364-1.06127506190503565i
+acos:0 0 0 0.904557-1.06128i 0.904556894302381-1.06127506190504i 0.904556894302381364-1.06127506190503565i
 atan:0.785398 0.785398163397448 0.78539816339744831 1.01722+0.402359i 1.01722196789785+0.402359478108525i 1.01722196789785137+0.402359478108525094i
 atan2:0.785398 0.785398163397448 0.78539816339744831 atan:0.785398 0.785398163397448 0.78539816339744831

tests/.expect/math3.txt

-              r933f32f
+              r6a9d4b4
 cosh:1.54308 1.54308063481524 1.54308063481524378 0.83373+0.988898i 0.833730025131149+0.988897705762865i 0.833730025131149049+0.988897705762865096i
 tanh:0.761594 0.761594155955765 0.761594155955764888 1.08392+0.271753i 1.08392332733869+0.271752585319512i 1.08392332733869454+0.271752585319511717i
 acosh:0. 0. 0. 1.06128+0.904557i 1.06127506190504+0.904556894302381i 1.06127506190503565+0.904556894302381364i
+acosh:0 0 0 1.06128+0.904557i 1.06127506190504+0.904556894302381i 1.06127506190503565+0.904556894302381364i
 asinh:0.881374 0.881373587019543 0.881373587019543025 1.06128+0.666239i 1.06127506190504+0.666239432492515i 1.06127506190503565+0.666239432492515255i
 atanh:inf inf inf 0.402359+1.01722i 0.402359478108525+1.01722196789785i 0.402359478108525094+1.01722196789785137i
 …
 lgamma:1.79176 1.79175946922805 1.791759469228055
 lgamma:1.79176 1 1.79175946922805 1 1.791759469228055 1
 tgamma:6. 6. 6.
+tgamma:6 6 6

tests/.expect/math4.txt

-              r933f32f
+              r6a9d4b4
 floor:1. 1. 1.
 ceil:2. 2. 2.
 trunc:3. 3. 3.
 rint:2. 2. 2.
+floor:1 1 1
+ceil:2 2 2
+trunc:3 3 3
+rint:2 2 2
 rint:2 2 2
 rint:2 2 2
 lrint:2 2 2
 llrint:2 2 2
 nearbyint:4. 4. 4.
 round:2. 2. 2.
+nearbyint:4 4 4
+round:2 2 2
 round:2 2 2
 round:2 2 2
 lround:2 2 2
 llround:2 2 2
 copysign:-1. -1. -1.
+copysign:-1 -1 -1
 frexp:0.5 3 0.5 3 0.5 3
 ldexp:8. 8. 8.
 modf:2. 0.3 2. 0.3 2. 0.3
 modf:2., 0.3 2., 0.3 2., 0.3
 nextafter:2. 2. 2.
 nexttoward:2. 2. 2.
 scalbn:16. 16. 16.
 scalbln:16. 16. 16.
+ldexp:8 8 8
+modf:2 0.3 2 0.3 2 0.3
+modf:2, 0.3 2, 0.3 2, 0.3
+nextafter:2 2 2
+nexttoward:2 2 2
+scalbn:16 16 16
+scalbln:16 16 16

tests/.expect/minmax.txt

-              r933f32f
+              r6a9d4b4
 signed long long int    4 3     min 3
 unsigned long long int  4 3     min 3
 float                   4. 3.1  min 3.1
 double                  4. 3.1  min 3.1
 long double             4. 3.1  min 3.1
+float                   4 3.1   min 3.1
+double                  4 3.1   min 3.1
+long double             4 3.1   min 3.1
 char                    z a     max z
 …
 signed long long int    4 3     max 4
 unsigned long long int  4 3     max 4
 float                   4. 3.1  max 4.
 double                  4. 3.1  max 4.
 long double             4. 3.1  max 4.
+float                   4 3.1   max 4
+double                  4 3.1   max 4
+long double             4 3.1   max 4

tests/.expect/references.txt

r933f32f	r6a9d4b4
35	35	3
36	36	3
37		3 9 { 1~~., 7.~~ }, [1, 2, 3]
	37	3 9 { 1, 7 }, [1, 2, 3]
38	38	Destructing a Y
39	39	Destructing a Y

tests/.expect/sum.txt

r933f32f	r6a9d4b4
1		~~sum from 5 to 15 is 95, check 95~~
2		~~sum from 5 to 15 is 95, check 95~~
3	1	sum from 5 to 15 is 95, check 95
4	2	sum from 5 to 15 is 95, check 95

tests/Makefile.am

-              r933f32f
+              r6a9d4b4
 installed=no
-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
 …
 timeouts=
 TEST_PY = python3 ${builddir}/test.py
+TEST_PY = python ${builddir}/test.py
 # applies to both programs
 …
         -Wno-unused-function \
         -quiet @CFA_FLAGS@ \
         -DIN_DIR="${abs_srcdir}/.in/"
+        -DIN_DIR="${srcdir}/.in/"
 AM_CFLAGS += ${DEBUG_FLAGS} ${INSTALL_FLAGS} ${ARCH_FLAGS}
 CC = @CFACC@
 PRETTY_PATH=mkdir -p $(dir $(abspath ${@})) && cd ${srcdir} &&
+PRETTY_PATH=cd ${srcdir} &&
 .PHONY: list .validate
 …
 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
 # automake doesn't know we still need C/CPP rules so pretend like we have a C program
 _dummy_hack_SOURCES = .dummy_hack.c .dummy_hackxx.cpp
+# automake doesn't know we still need C rules so pretend like we have a C program
+_dummy_hack_SOURCES = .dummy_hack.c
 #----------------------------------------------------------------------------------------------------------------
 …
         @echo "int main() { return 0; }" > ${@}
-.dummy_hackxx.cpp:
-        @echo "int bar() { return 0; }" > ${@}
 concurrency :
         @+${TEST_PY} --debug=${debug}  --install=${installed} -Iconcurrent
 …
 #----------------------------------------------------------------------------------------------------------------
-# 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 "${@}_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
 % : %.cfa $(CFACC)
         $(CFATEST_STDOUT)
+        $(PRETTY_PATH) $(CFACOMPILE) $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
+% : %.cpp
         $(PRETTY_PATH) $(CXXCOMPILE) $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
+declarationSpecifier: declarationSpecifier.cfa $(CFACC)
+        $(PRETTY_PATH) $(CFACOMPILE) -CFA -XCFA -p $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
+#------------------------------------------------------------------------------
+# TARGET WITH STANDARD RULE BUT CUSTOM FLAGS
+#------------------------------------------------------------------------------
+# 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
+gccExtensions : gccExtensions.cfa $(CFACC)
+        $(PRETTY_PATH) $(CFACOMPILE) -CFA -XCFA -p $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
+#------------------------------------------------------------------------------
+# Expected failures
+completeTypeError_FLAGS= -DERR1
+extension : extension.cfa $(CFACC)
+        $(PRETTY_PATH) $(CFACOMPILE) -CFA -XCFA -p $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
+#------------------------------------------------------------------------------
+# CUSTOM TARGET
+#------------------------------------------------------------------------------
+typedefRedef-ERR1: typedefRedef.cfa $(CFACC)
+        $(CFATEST_STDOUT) -DERR1
+attributes : attributes.cfa $(CFACC)
+        $(PRETTY_PATH) $(CFACOMPILE) -CFA -XCFA -p $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
 alloc-ERROR: alloc.cfa $(CFACC)
         $(CFATEST_STDOUT) -DERR1
+functions: functions.cfa $(CFACC)
+        $(PRETTY_PATH) $(CFACOMPILE) -CFA -XCFA -p $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
 nested-types-ERR1: nested-types.cfa $(CFACC)
         $(CFATEST_STDOUT) -DERR1
+KRfunctions : KRfunctions.cfa $(CFACC)
+        $(PRETTY_PATH) $(CFACOMPILE) -CFA -XCFA -p $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
 nested-types-ERR2: nested-types.cfa $(CFACC)
         $(CFATEST_STDOUT) -DERR2
+sched-ext-parse : sched-ext-parse.c $(CFACC)
+        $(PRETTY_PATH) $(CFACOMPILE) -CFA -XCFA -p $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
+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
+gmp : gmp.cfa $(CFACC)
+        $(PRETTY_PATH) $(CFACOMPILE) -lgmp $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
 #builtins
 builtins/sync: builtins/sync.cfa $(CFACC)
+        $(CFATEST_STDERR) -fsyntax-only
+        $(PRETTY_PATH) $(CFACOMPILE) $(shell realpath --relative-to=${srcdir} ${<}) 2> $(abspath ${@}) -fsyntax-only
+#------------------------------------------------------------------------------
+#To make errors path independent we need to cd into the correct directories
+completeTypeError : completeTypeError.cfa $(CFACC)
+        $(PRETTY_PATH) $(CFACOMPILE) -DERR1 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
+typedefRedef-ERR1: typedefRedef.cfa $(CFACC)
+        $(PRETTY_PATH) $(CFACOMPILE) -DERR1 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
+alloc-ERROR: alloc.cfa $(CFACC)
+        $(PRETTY_PATH) $(CFACOMPILE) -DERR1 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
+fallthrough-ERROR: fallthrough.cfa $(CFACC)
+        $(PRETTY_PATH) $(CFACOMPILE) -DERR1 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
+nested-types-ERR1: nested-types.cfa $(CFACC)
+        $(PRETTY_PATH) $(CFACOMPILE) -DERR1 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
+nested-types-ERR2: nested-types.cfa $(CFACC)
+        $(PRETTY_PATH) $(CFACOMPILE) -DERR2 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
+# Constructor/destructor tests
+raii/dtor-early-exit-ERR1: raii/dtor-early-exit.cfa $(CFACC)
+        $(PRETTY_PATH) $(CFACOMPILE) -DERR1 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
+raii/dtor-early-exit-ERR2: raii/dtor-early-exit.cfa $(CFACC)
+        $(PRETTY_PATH) $(CFACOMPILE) -DERR2 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
+raii/memberCtors-ERR1: raii/memberCtors.cfa $(CFACC)
+        $(PRETTY_PATH) $(CFACOMPILE) -DERR1 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
+raii/ctor-autogen-ERR1: raii/ctor-autogen.cfa $(CFACC)
+        $(PRETTY_PATH) $(CFACOMPILE) -DERR1 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
 # Warnings
 warnings/self-assignment: warnings/self-assignment.cfa $(CFACC)
         $(CFATEST_STDERR) -fsyntax-only
+        $(PRETTY_PATH) $(CFACOMPILE) $(shell realpath --relative-to=${srcdir} ${<}) 2> $(abspath ${@}) -fsyntax-only

tests/Makefile.in

-              r933f32f
+              r6a9d4b4
 CONFIG_CLEAN_FILES = config.py
 CONFIG_CLEAN_VPATH_FILES = test.py
 am__dummy_hack_OBJECTS = .dummy_hack.$(OBJEXT) .dummy_hackxx.$(OBJEXT)
+am__dummy_hack_OBJECTS = .dummy_hack.$(OBJEXT)
 _dummy_hack_OBJECTS = $(am__dummy_hack_OBJECTS)
 _dummy_hack_LDADD = $(LDADD)
 …
 am__v_CCLD_0 = @echo "  CCLD    " $@;
 am__v_CCLD_1 =
-CXXCOMPILE = $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) \
-        $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS)
-LTCXXCOMPILE = $(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) \
-        $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) \
-        $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) \
-        $(AM_CXXFLAGS) $(CXXFLAGS)
-AM_V_CXX = $(am__v_CXX_@AM_V@)
-am__v_CXX_ = $(am__v_CXX_@AM_DEFAULT_V@)
-am__v_CXX_0 = @echo "  CXX     " $@;
-am__v_CXX_1 =
-CXXLD = $(CXX)
-CXXLINK = $(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) \
-        $(LIBTOOLFLAGS) --mode=link $(CXXLD) $(AM_CXXFLAGS) \
-        $(CXXFLAGS) $(AM_LDFLAGS) $(LDFLAGS) -o $@
-AM_V_CXXLD = $(am__v_CXXLD_@AM_V@)
-am__v_CXXLD_ = $(am__v_CXXLD_@AM_DEFAULT_V@)
-am__v_CXXLD_0 = @echo "  CXXLD   " $@;
-am__v_CXXLD_1 =
 SOURCES = $(_dummy_hack_SOURCES) $(avl_test_SOURCES)
 DIST_SOURCES = $(_dummy_hack_SOURCES) $(avl_test_SOURCES)
 …
 DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)
 ACLOCAL = @ACLOCAL@
+ALLOCA = @ALLOCA@
 AMTAR = @AMTAR@
 AM_DEFAULT_VERBOSITY = @AM_DEFAULT_VERBOSITY@
 …
 debug = yes
 installed = no
-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
 concurrent =
 timeouts =
 TEST_PY = python3 ${builddir}/test.py
+TEST_PY = python ${builddir}/test.py
 # applies to both programs
 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} &&
+        -quiet @CFA_FLAGS@ -DIN_DIR="${srcdir}/.in/" ${DEBUG_FLAGS} \
+        ${INSTALL_FLAGS} ${ARCH_FLAGS}
+PRETTY_PATH = 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
+# automake doesn't know we still need C/CPP rules so pretend like we have a C program
+_dummy_hack_SOURCES = .dummy_hack.c .dummy_hackxx.cpp
+#----------------------------------------------------------------------------------------------------------------
+# 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 "${@}_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 ${@})
+#------------------------------------------------------------------------------
+# TARGET WITH STANDARD RULE BUT CUSTOM FLAGS
+#------------------------------------------------------------------------------
+# 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
+#------------------------------------------------------------------------------
+# Expected failures
+completeTypeError_FLAGS = -DERR1
+# automake doesn't know we still need C rules so pretend like we have a C program
+_dummy_hack_SOURCES = .dummy_hack.c
 all: all-am
 .SUFFIXES:
 .SUFFIXES: .c .cfa .cpp .dummy_hack .dummy_hackxx .lo .o .obj .validate
+.SUFFIXES: .c .cfa .dummy_hack .lo .o .obj .validate
 $(srcdir)/Makefile.in:  $(srcdir)/Makefile.am $(top_srcdir)/src/cfa.make $(am__configure_deps)
         @for dep in $?; do \
 …
 .dummy_hack$(EXEEXT): $(_dummy_hack_OBJECTS) $(_dummy_hack_DEPENDENCIES) $(EXTRA__dummy_hack_DEPENDENCIES)
         @rm -f .dummy_hack$(EXEEXT)
         $(AM_V_CXXLD)$(CXXLINK) $(_dummy_hack_OBJECTS) $(_dummy_hack_LDADD) $(LIBS)
+        $(AM_V_CCLD)$(LINK) $(_dummy_hack_OBJECTS) $(_dummy_hack_LDADD) $(LIBS)
 avltree/$(am__dirstamp):
         @$(MKDIR_P) avltree
 …
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/.dummy_hack.Po@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/.dummy_hackxx.Po@am__quote@
 .c.o:
 …
 @AMDEP_TRUE@@am__fastdepCC_FALSE@       DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
 @am__fastdepCC_FALSE@   $(AM_V_CC@am__nodep@)$(LTCOMPILE) -c -o $@ $<
-.cpp.o:
-@am__fastdepCXX_TRUE@   $(AM_V_CXX)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.o$$||'`;\
-@am__fastdepCXX_TRUE@   $(CXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\
-@am__fastdepCXX_TRUE@   $(am__mv) $$depbase.Tpo $$depbase.Po
-@AMDEP_TRUE@@am__fastdepCXX_FALSE@      $(AM_V_CXX)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
-@AMDEP_TRUE@@am__fastdepCXX_FALSE@      DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
-@am__fastdepCXX_FALSE@  $(AM_V_CXX@am__nodep@)$(CXXCOMPILE) -c -o $@ $<
-.cpp.obj:
-@am__fastdepCXX_TRUE@   $(AM_V_CXX)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.obj$$||'`;\
-@am__fastdepCXX_TRUE@   $(CXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ `$(CYGPATH_W) '$<'` &&\
-@am__fastdepCXX_TRUE@   $(am__mv) $$depbase.Tpo $$depbase.Po
-@AMDEP_TRUE@@am__fastdepCXX_FALSE@      $(AM_V_CXX)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
-@AMDEP_TRUE@@am__fastdepCXX_FALSE@      DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
-@am__fastdepCXX_FALSE@  $(AM_V_CXX@am__nodep@)$(CXXCOMPILE) -c -o $@ `$(CYGPATH_W) '$<'`
-.cpp.lo:
-@am__fastdepCXX_TRUE@   $(AM_V_CXX)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.lo$$||'`;\
-@am__fastdepCXX_TRUE@   $(LTCXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\
-@am__fastdepCXX_TRUE@   $(am__mv) $$depbase.Tpo $$depbase.Plo
-@AMDEP_TRUE@@am__fastdepCXX_FALSE@      $(AM_V_CXX)source='$<' object='$@' libtool=yes @AMDEPBACKSLASH@
-@AMDEP_TRUE@@am__fastdepCXX_FALSE@      DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
-@am__fastdepCXX_FALSE@  $(AM_V_CXX@am__nodep@)$(LTCXXCOMPILE) -c -o $@ $<
 mostlyclean-libtool:
 …
         @echo "int main() { return 0; }" > ${@}
-.dummy_hackxx.cpp:
-        @echo "int bar() { return 0; }" > ${@}
 concurrency :
         @+${TEST_PY} --debug=${debug}  --install=${installed} -Iconcurrent
 …
 # implicit rule so not all test require a rule
 % : %.cfa $(CFACC)
+        $(CFATEST_STDOUT)
+% : %.cpp
+        $(PRETTY_PATH) $(CXXCOMPILE) $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
+#------------------------------------------------------------------------------
+# CUSTOM TARGET
+#------------------------------------------------------------------------------
+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
+        $(PRETTY_PATH) $(CFACOMPILE) $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
+declarationSpecifier: declarationSpecifier.cfa $(CFACC)
+        $(PRETTY_PATH) $(CFACOMPILE) -CFA -XCFA -p $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
+gccExtensions : gccExtensions.cfa $(CFACC)
+        $(PRETTY_PATH) $(CFACOMPILE) -CFA -XCFA -p $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
+extension : extension.cfa $(CFACC)
+        $(PRETTY_PATH) $(CFACOMPILE) -CFA -XCFA -p $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
+attributes : attributes.cfa $(CFACC)
+        $(PRETTY_PATH) $(CFACOMPILE) -CFA -XCFA -p $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
+functions: functions.cfa $(CFACC)
+        $(PRETTY_PATH) $(CFACOMPILE) -CFA -XCFA -p $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
+KRfunctions : KRfunctions.cfa $(CFACC)
+        $(PRETTY_PATH) $(CFACOMPILE) -CFA -XCFA -p $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
+sched-ext-parse : sched-ext-parse.c $(CFACC)
+        $(PRETTY_PATH) $(CFACOMPILE) -CFA -XCFA -p $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
+gmp : gmp.cfa $(CFACC)
+        $(PRETTY_PATH) $(CFACOMPILE) -lgmp $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
 #builtins
 builtins/sync: builtins/sync.cfa $(CFACC)
+        $(CFATEST_STDERR) -fsyntax-only
+        $(PRETTY_PATH) $(CFACOMPILE) $(shell realpath --relative-to=${srcdir} ${<}) 2> $(abspath ${@}) -fsyntax-only
+#------------------------------------------------------------------------------
+#To make errors path independent we need to cd into the correct directories
+completeTypeError : completeTypeError.cfa $(CFACC)
+        $(PRETTY_PATH) $(CFACOMPILE) -DERR1 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
+typedefRedef-ERR1: typedefRedef.cfa $(CFACC)
+        $(PRETTY_PATH) $(CFACOMPILE) -DERR1 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
+alloc-ERROR: alloc.cfa $(CFACC)
+        $(PRETTY_PATH) $(CFACOMPILE) -DERR1 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
+fallthrough-ERROR: fallthrough.cfa $(CFACC)
+        $(PRETTY_PATH) $(CFACOMPILE) -DERR1 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
+nested-types-ERR1: nested-types.cfa $(CFACC)
+        $(PRETTY_PATH) $(CFACOMPILE) -DERR1 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
+nested-types-ERR2: nested-types.cfa $(CFACC)
+        $(PRETTY_PATH) $(CFACOMPILE) -DERR2 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
+# Constructor/destructor tests
+raii/dtor-early-exit-ERR1: raii/dtor-early-exit.cfa $(CFACC)
+        $(PRETTY_PATH) $(CFACOMPILE) -DERR1 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
+raii/dtor-early-exit-ERR2: raii/dtor-early-exit.cfa $(CFACC)
+        $(PRETTY_PATH) $(CFACOMPILE) -DERR2 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
+raii/memberCtors-ERR1: raii/memberCtors.cfa $(CFACC)
+        $(PRETTY_PATH) $(CFACOMPILE) -DERR1 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
+raii/ctor-autogen-ERR1: raii/ctor-autogen.cfa $(CFACC)
+        $(PRETTY_PATH) $(CFACOMPILE) -DERR1 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
 # Warnings
 warnings/self-assignment: warnings/self-assignment.cfa $(CFACC)
         $(CFATEST_STDERR) -fsyntax-only
+        $(PRETTY_PATH) $(CFACOMPILE) $(shell realpath --relative-to=${srcdir} ${<}) 2> $(abspath ${@}) -fsyntax-only
 # Tell versions [3.59,3.63) of GNU make to not export all variables.

tests/array.cfa

-              r933f32f
+              r6a9d4b4
+//                               -*- Mode: C -*-
+//
+// Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo
+//
+// The contents of this file are covered under the licence agreement in the
+// file "LICENCE" distributed with Cforall.
+//
+// array.cfa -- test array declarations
+//
+// Author           : Peter A. Buhr
+// Created On       : Tue Feb 19 21:18:06 2019
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Tue Feb 19 21:18:46 2019
+// Update Count     : 1
+//
+//Testing array declarations
 int a1[];
 //int a2[*];
 …
+}
+int main() {}
+// Local Variables: //
+// tab-width: 4 //
+// compile-command: "cfa array.cfa" //
+// End: //
+//Dummy main
+int main(int argc, char const *argv[])
+{
+        return 0;
+}

tests/builtins/sync.cfa

-              r933f32f
+              r6a9d4b4
         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(vp1, v1); }
 …
         { _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(vp1, v1, v1); }
 …
         { __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(vp1, v1); }
 …
         { __atomic_clear(vp1, v1); }
         { char ret; ret = __atomic_exchange_n(vp1, v1, __ATOMIC_SEQ_CST); }
+        { 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_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_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_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_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(vp1, __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(vp1, rp1, v1, false, __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(vp1, v1, __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(vp1, v1, __ATOMIC_SEQ_CST); }

tests/castError.cfa

-              r933f32f
+              r6a9d4b4
+//
+// Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo
+//
+// The contents of this file are covered under the licence agreement in the
+// file "LICENCE" distributed with Cforall.
+//
+// castError.cfa -- test invalid casts
+//
+// Author           : Peter A. Buhr
+// Created On       : Tue Feb 19 21:15:39 2019
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Tue Feb 19 21:16:44 2019
+// Update Count     : 1
+//
+//Testing some of the invalid casts of chars
 int f;
 …
         (char)f;
         (int(*)())f;
-        unsigned char v;
-        short int v;
-, v;           // implicit void cast
+}
+int main() {}
+// Local Variables: //
+// tab-width: 4 //
+// compile-command: "cfa castError.cfa" //
+// End: //
+//Dummy main
+int main(int argc, char const *argv[])
+{
+        return 0;
+}

tests/completeTypeError.cfa

-              r933f32f
+              r6a9d4b4
 forall(dtype T | sized(T)) void quux(T *);
 struct A;       // incomplete
 struct B {};    // complete
+struct A; // incomplete
+struct B {}; // complete
 int main() {
         int * i;
         void * v;
+        int *i;
+        void *v;
         A * x;
 …
         // okay
         *i;
         *y;
+        *x; // picks B
         *z;
         foo(i);
 …
         // bad
         *v;
         *x;     // ambiguous
+        *y;
         foo(v);
         baz(v);
 …
 void qux(T * y) {
         // okay
-        *y;
         bar(y);
         qux(y);
 …
         baz(y);
         quux(y);
+        *y;
+}

tests/concurrent/examples/boundedBufferEXT.cfa

-              r933f32f
+              r6a9d4b4
 //
-// Cforall Version 1.0.0 Copyright (C) 2018 University of Waterloo
-//
 // The contents of this file are covered under the licence agreement in the
 // file "LICENCE" distributed with Cforall.
 …
 // Created On       : Wed Apr 18 22:52:12 2018
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Mar 22 13:41:33 2019
 // Update Count     : 12
+// Last Modified On : Tue Dec 11 21:55:02 2018
+// Update Count     : 9
 //
 #include <stdlib.hfa>                                                                   // random
+#include <stdlib.hfa>                                                                           // random
 #include <fstream.hfa>
 #include <kernel.hfa>
 …
 // Local Variables: //
 // tab-width: 4 //
 // compile-command: "cfa boundedBufferEXT.cfa" //
+// compile-command: "cfa boundedBufferEXT.c" //
 // End: //

tests/concurrent/examples/boundedBufferINT.cfa

-              r933f32f
+              r6a9d4b4
 //
-// 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.
 …
 // Created On       : Mon Oct 30 12:45:13 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Mar 22 13:41:52 2019
 // Update Count     : 88
+// Last Modified On : Tue Dec 11 21:55:45 2018
+// Update Count     : 84
 //
 #include <stdlib.hfa>                                                                   // random
+#include <stdlib.hfa>                                                                           // random
 #include <fstream.hfa>
 #include <kernel.hfa>
 …
 // Local Variables: //
 // tab-width: 4 //
 // compile-command: "cfa boundedBufferINT.cfa" //
+// compile-command: "cfa boundedBufferINT.c" //
 // End: //

tests/concurrent/examples/datingService.cfa

-              r933f32f
+              r6a9d4b4
 //
-// 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.
 …
 // Created On       : Mon Oct 30 12:56:20 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Mar 22 13:41:39 2019
 // Update Count     : 31
+// Last Modified On : Tue Dec 11 21:55:34 2018
+// Update Count     : 28
 //
 #include <stdlib.hfa>                                                                   // random
+#include <stdlib.hfa>                                                                           // random
 #include <fstream.hfa>
 #include <kernel.hfa>
 …
 // Local Variables: //
 // tab-width: 4 //
 // compile-command: "cfa datingService.cfa" //
+// compile-command: "cfa datingService.c" //
 // End: //

tests/concurrent/examples/matrixSum.cfa

-              r933f32f
+              r6a9d4b4
+//                               -*- Mode: C -*-
 //
 // Cforall Version 1.0.0 Copyright (C) 2017 University of Waterloo
 …
 // Created On       : Mon Oct  9 08:29:28 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed Feb 20 08:37:53 2019
 // Update Count     : 16
+// Last Modified On : Tue Dec 11 21:54:55 2018
+// Update Count     : 15
 //

tests/concurrent/examples/quickSort.cfa

-              r933f32f
+              r6a9d4b4
-//
-// Cforall Version 1.0.0 Copyright (C) 2017 University of Waterloo
 //
 // The contents of this file are covered under the licence agreement in the
 …
 // Created On       : Wed Dec  6 12:15:52 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Mar 22 13:42:01 2019
 // Update Count     : 170
+// Last Modified On : Sat Dec 22 08:44:27 2018
+// Update Count     : 168
 //
 …
 // Local Variables: //
 // tab-width: 4 //
 // compile-command: "cfa quickSort.cfa" //
+// compile-command: "cfa quickSort.c" //
 // End: //

tests/concurrent/waitfor/parse2.cfa

-              r933f32f
+              r6a9d4b4
 // Created On       : Wed Aug 30 17:53:29 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Mar 22 13:42:11 2019
 // Update Count     : 3
+// Last Modified On : Wed Aug 30 17:55:17 2017
+// Update Count     : 2
 //
 …
 // Local Variables: //
 // tab-width: 4 //
 // compile-command: "cfa waitfor.cfa" //
+// compile-command: "cfa waitfor.c" //
 // End: //

tests/config.py.in

r933f32f	r6a9d4b4
1		#!/usr/bin/env python3
	1	#!/usr/bin/env python
2	2	# encoding: utf-8
3	3	"""

tests/coroutine/.expect/fmtLines.txt

-              r933f32f
+              r6a9d4b4
 difi  ed B  y :   Pete  r A.
  Buh  r//   Last   Mod  ifie
 d On   : F  ri M  ar 2  2 13
 :41:  03 2  019/  / Up  date
  Cou  nt       :   33/  /#in
+d On   : T  ue D  ec 1  1 23
+:31:  12 2  018/  / Up  date
+ Cou  nt       :   32/  /#in
 clud  e <f  stre  am.h  fa>#
 incl  ude   <cor  outi  ne.h
 …
 th:   4 //  // c  ompi  le-c
 omma  nd:   "cfa   fmt  Line
 s.cf  a" /  ///   End:   //
+s.c"   ///  / En  d: /  /

tests/coroutine/.in/fmtLines.txt

-              r933f32f
+              r6a9d4b4
 // Created On       : Sun Sep 17 21:56:15 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Mar 22 13:41:03 2019
 // Update Count     : 33
+// Last Modified On : Tue Dec 11 23:31:12 2018
+// Update Count     : 32
 //
 …
 // Local Variables: //
 // tab-width: 4 //
 // compile-command: "cfa fmtLines.cfa" //
+// compile-command: "cfa fmtLines.c" //
 // End: //

tests/coroutine/fibonacci.cfa

-              r933f32f
+              r6a9d4b4
 // Created On       : Thu Jun  8 07:29:37 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Mar 22 13:40:35 2019
 // Update Count     : 26
+// Last Modified On : Tue Dec 11 21:57:33 2018
+// Update Count     : 25
 //
 …
 // Local Variables: //
 // tab-width: 4 //
 // compile-command: "cfa fibonacci.cfa" //
+// compile-command: "cfa fibonacci.c" //
 // End: //

tests/coroutine/fibonacci_1.cfa

-              r933f32f
+              r6a9d4b4
 // file "LICENCE" distributed with Cforall.
 //
 // fibonacci_1.cfa -- 1-state finite-state machine: precomputed first two states returning f(n - 1)
+// fibonacci_1.c -- 1-state finite-state machine: precomputed first two states returning f(n - 2)
 //
 // Author           : Peter A. Buhr
 // Created On       : Thu Apr 26 23:20:08 2018
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Mar 21 08:10:45 2019
 // Update Count     : 25
+// Last Modified On : Tue Dec 11 21:57:54 2018
+// Update Count     : 14
 //
 …
 #include <coroutine.hfa>
 coroutine Fibonacci { int fn1; };                                               // used for communication
+coroutine Fibonacci { int ret; };                                               // used for communication
 void main( Fibonacci & fib ) with( fib ) {                              // called on first resume
+        int fn;
+        [fn1, fn] = [0, 1];                                                                     // precompute first two states
+        int fn, fn1 = 1, fn2 = 0;                                                       // precompute first two states
         for () {
+                ret = fn2;
+                fn = fn1 + fn2;  fn2 = fn1;  fn1 = fn;                  // general case
                 suspend();                                                                              // restart last resume
-                [fn1, fn] = [fn, fn1 + fn];                                             // general case
         } // for
+}
 …
 int next( Fibonacci & fib ) with( fib ) {
         resume( fib );                                                                          // restart last suspend
         return fn1;
+        return ret;
+}
 …
 // Local Variables: //
 // tab-width: 4 //
 // compile-command: "cfa fibonacci_1.cfa" //
+// compile-command: "cfa fibonacci_1.c" //
 // End: //

tests/coroutine/fmtLines.cfa

-              r933f32f
+              r6a9d4b4
 // Created On       : Sun Sep 17 21:56:15 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Mar 22 13:41:16 2019
 // Update Count     : 58
+// Last Modified On : Sat Dec 22 18:27:00 2018
+// Update Count     : 57
 //
 …
 // Local Variables: //
 // tab-width: 4 //
 // compile-command: "cfa fmtLines.cfa" //
+// compile-command: "cfa fmtLines.c" //
 // End: //

tests/coroutine/pingpong.cfa

-              r933f32f
+              r6a9d4b4
 // Created On       : Wed Sep 20 11:55:23 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Tue Mar 26 17:54:14 2019
 // Update Count     : 35
+// Last Modified On : Tue Dec 11 21:58:06 2018
+// Update Count     : 29
 //
 …
         const char * name;
         /* const */ unsigned int N;
         PingPong & part;
+        PingPong * part;
 };
 void ?{}( PingPong & this, const char * name, unsigned int N, PingPong & part ) {
+        this.[name, N] = [name, N];  &this.part = &part;
+        (this.__cor){name};
+        this.name = name;
+        this.N = N;
+        this.part = &part;
+}
 void ?{}( PingPong & this, const char * name, unsigned int N ) {
         this{ name, N, *0p };                                                           // call first constructor
+        this{ name, N, *(PingPong *)0 };
+}
 void cycle( PingPong & pingpong ) {
 …
+}
 void partner( PingPong & this, PingPong & part ) {
         &this.part = &part;
+        this.part = &part;
         resume( this );
+}
 void main( PingPong & pingpong ) with(pingpong) {               // ping's starter ::main, pong's starter ping
         for ( N ) {                                                                                     // N ping-pongs
                 sout | name;
                 cycle( part );
+void main( PingPong & pingpong ) {                                              // ping's starter ::main, pong's starter ping
+        for ( pingpong.N ) {                                                            // N ping-pongs
+                sout | pingpong.name;
+                cycle( *pingpong.part );
         } // for
+}
 …
 // Local Variables: //
 // tab-width: 4 //
 // compile-command: "cfa pingpong.cfa" //
+// compile-command: "cfa pingpong.c" //
 // End: //

tests/coroutine/prodcons.cfa

-              r933f32f
+              r6a9d4b4
 // Created On       : Mon Sep 18 12:23:39 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Mar 22 13:41:10 2019
 // Update Count     : 54
+// Last Modified On : Wed Dec 12 23:04:49 2018
+// Update Count     : 53
 //
 …
 // Local Variables: //
 // tab-width: 4 //
 // compile-command: "cfa prodcons.cfa" //
+// compile-command: "cfa prodcons.c" //
 // End: //

tests/coroutine/runningTotal.cfa

-              r933f32f
+              r6a9d4b4
 // Created On       : Wed Dec  6 08:05:27 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Mar 22 13:40:49 2019
 // Update Count     : 5
+// Last Modified On : Tue Dec 11 21:59:00 2018
+// Update Count     : 4
 //
 …
 // Local Variables: //
 // tab-width: 4 //
 // compile-command: "cfa runningTotal.cfa" //
+// compile-command: "cfa runningTotal.c" //
 // End: //

tests/declarationSpecifier.cfa

-              r933f32f
+              r6a9d4b4
 // Created On       : Wed Aug 17 08:21:04 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Tue Apr 30 18:20:36 2019
 // Update Count     : 4
+// Last Modified On : Tue Nov  6 17:52:59 2018
+// Update Count     : 3
 //
 …
 //Dummy main
+int main( int argc, char const * argv[] ) {}
+int main(int argc, char const *argv[])
+{
+        return 0;
+}
 // Local Variables: //

tests/forall.cfa

-              r933f32f
+              r6a9d4b4
 // Created On       : Wed May  9 08:48:15 2018
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Tue Mar 19 08:29:38 2019
 // Update Count     : 32
+// Last Modified On : Tue Nov  6 17:53:43 2018
+// Update Count     : 31
 //
 …
         right = temp;
+}
+void ?{}( int & c, zero_t ) { c = 0; }                                  // not in prelude
 trait sumable( otype T ) {

tests/function-operator.cfa

-              r933f32f
+              r6a9d4b4
 // Created On       : Fri Aug 25 15:21:11 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Apr 11 18:27:45 2019
 // Update Count     : 10
+// Last Modified On : Tue Dec  4 21:37:09 2018
+// Update Count     : 9
 //
 …
 // test ?()(T, ...) -- ?() with function call-by-reference
 forall(otype Generator, otype GenRet | { GenRet ?()(Generator &); }, dtype Iter, otype T | Iterator(Iter, T) | Assignable(T, GenRet))
+forall(otype Generator, otype GenRet | { GenRet ?()(Generator &); }, dtype Iter, otype T| Iterator(Iter, T) | Assignable(T, GenRet))
 void generate(Iter first, Iter last, Generator & gen) {
         int i = 0;

tests/io1.cfa

-              r933f32f
+              r6a9d4b4
 // Created On       : Wed Mar  2 16:56:02 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Mon Mar  4 21:42:47 2019
 // Update Count     : 115
+// Last Modified On : Fri Dec 21 16:02:55 2018
+// Update Count     : 114
 //
 …
         int x = 3, y = 5, z = 7;
         sout | x * 3 | y + 1 | z << 2 | x == y | (x | y) | (x || y) | (x > z ? 1 : 2);
         sout | 0 | 1 | 2 | 3;
         sout | '0' | '1' | '2' | '3';
         sout | 0 | "" | 1 | "" | 2 | "" | 3;
+        sout | 1 | 2 | 3;
+        sout | '1' | '2' | '3';
+        sout | 1 | "" | 2 | "" | 3;
         sout | nl;

tests/io2.cfa

-              r933f32f
+              r6a9d4b4
 // Created On       : Wed Mar  2 16:56:02 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Apr 18 08:03:30 2019
 // Update Count     : 113
+// Last Modified On : Fri Dec 21 08:20:14 2018
+// Update Count     : 112
 //
 …
         sout | 1 | sepOff | 2 | 3;                                                      // locally turn off implicit separator
         sout | sepOn | sepOn | 1 | 2 | 3 | sepOn | sepOff | sepOn | '\n' | nonl; // no separator at start/end of line
         sout | 1 | 2 | 3 | "\n\n" | sepOn | nonl;                       // no separator at start of next line
+        sout | 1 | 2 | 3 | "\n\n" | sepOn | nonl;                                       // no separator at start of next line
         sout | 1 | 2 | 3;
         sout | nl;

tests/literals.cfa

-              r933f32f
+              r6a9d4b4
 // Created On       : Sat Sep  9 16:34:38 2017
 // Last Modified By : Peter A. Buhr
+// Last Modified On : Tue Feb 12 08:07:39 2019
+// Update Count     : 224
+//
+#include <features.h>                                                                   // __GNUC_PREREQ
+// Last Modified On : Tue Dec  4 21:44:01 2018
+// Update Count     : 139
+//
 #ifdef __CFA__
+#include <stdint.h>
 #include <fstream.hfa>
 …
         -0X0123456789.0123456789P-09;  -0X0123456789.0123456789P-09f;  -0X0123456789.0123456789P-09l;  -0X0123456789.0123456789P-09F;  -0X0123456789.0123456789P-09L;
-#if defined(__GNUC__) && __GNUC_PREREQ(7,0)                             // gcc version >= 7
-// floating with length, gcc f16/f128x unsupported and no prelude code for any _FloatXXx, so they work by conversion to long double
-        /*  0123456789.f16; */   0123456789.f32;   0123456789.f32x;   0123456789.f64;   0123456789.f64x;   0123456789.W;   0123456789.f128;   0123456789.q;  /*  0123456789.f128x; */
-        /* +0123456789.f16; */  +0123456789.f32;  +0123456789.f32x;  +0123456789.f64;  +0123456789.f64x;  +0123456789.w;  +0123456789.f128;  +0123456789.Q;  /* +0123456789.f128x; */
-        /* -0123456789.f16; */  -0123456789.f32;  -0123456789.f32x;  -0123456789.f64;  -0123456789.f64x;  -0123456789.W;  -0123456789.f128;  -0123456789.q;  /* -0123456789.f128x; */
-        /*  0123456789.e09F16; */    0123456789.e09F32;    0123456789.e09F32x;    0123456789.e09F64;    0123456789.e09F64x;    0123456789.e09W;    0123456789.e09F128;    0123456789.e09q;   /*  .0123456789e09q; */
-        /* +0123456789.e+09F16; */  +0123456789.e+09F32;  +0123456789.e+09F32x;  +0123456789.e+09F64;  +0123456789.e+09F64x;  +0123456789.e+09w;  +0123456789.e+09F128;  +0123456789.e+09Q;  /* +.0123456789E+09Q; */
-        /* -0123456789.e-09F16; */  -0123456789.e-09F32;  -0123456789.e-09F32x;  -0123456789.e-09F64;  -0123456789.e-09F64x;  -0123456789.e-09W;  -0123456789.e-09F128;  -0123456789.e-09q;  /* -.0123456789E-09q; */
-        /*  .0123456789e09F16; */    .0123456789e09F32;    .0123456789e09F32x;    .0123456789e09F64;    .0123456789e09F64x;    .0123456789e09W;    .0123456789e09F128;    .0123456789e09q;   /*  .0123456789e09q; */
-        /* +.0123456789e+09F16; */  +.0123456789e+09F32;  +.0123456789e+09F32x;  +.0123456789e+09F64;  +.0123456789e+09F64x;  +.0123456789e+09w;  +.0123456789e+09F128;  +.0123456789e+09Q;  /* +.0123456789E+09Q; */
-        /* -.0123456789e-09F16; */  -.0123456789e-09F32;  -.0123456789e-09F32x;  -.0123456789e-09F64;  -.0123456789e-09F64x;  -.0123456789e-09W;  -.0123456789e-09F128;  -.0123456789e-09q;  /* -.0123456789E-09q; */
-        /*  0123456789.0123456789F16; */   0123456789.0123456789F32;   0123456789.0123456789F32x;   0123456789.0123456789F64;   0123456789.0123456789F64x;   0123456789.0123456789W;   0123456789.0123456789F128;   0123456789.0123456789q;  /*  0123456789.0123456789q; */
-        /* +0123456789.0123456789F16; */  +0123456789.0123456789F32;  +0123456789.0123456789F32x;  +0123456789.0123456789F64;  +0123456789.0123456789F64x;  +0123456789.0123456789w;  +0123456789.0123456789F128;  +0123456789.0123456789Q;  /* +0123456789.0123456789Q; */
-        /* -0123456789.0123456789F16; */  -0123456789.0123456789F32;  -0123456789.0123456789F32x;  -0123456789.0123456789F64;  -0123456789.0123456789F64x;  -0123456789.0123456789W;  -0123456789.0123456789F128;  -0123456789.0123456789q;  /* -0123456789.0123456789q; */
-        /*  0123456789.0123456789E09F16; */    0123456789.0123456789E09F32;    0123456789.0123456789E09F32x;    0123456789.0123456789E09F64;    0123456789.0123456789E09F64x;    0123456789.0123456789E09W;    0123456789.0123456789E09F128;    0123456789.0123456789E09q;   /*  0123456789.0123456789E09q; */
-        /* +0123456789.0123456789E+09F16; */  +0123456789.0123456789E+09F32;  +0123456789.0123456789E+09F32x;  +0123456789.0123456789E+09F64;  +0123456789.0123456789E+09F64x;  +0123456789.0123456789E+09w;  +0123456789.0123456789E+09F128;  +0123456789.0123456789E+09Q;  /* +0123456789.0123456789E+09Q; */
-        /* -0123456789.0123456789E-09F16; */  -0123456789.0123456789E-09F32;  -0123456789.0123456789E-09F32x;  -0123456789.0123456789E-09F64;  -0123456789.0123456789E-09F64x;  -0123456789.0123456789E-09W;  -0123456789.0123456789E-09F128;  -0123456789.0123456789E-09q;  /* -0123456789.0123456789E-09q; */
-        /*  0x123456789.p09f16; */    0x123456789.p09f32;    0x123456789.p09f32x;    0x123456789.p09f64;    0x123456789.p09f64x;    0x123456789.p09W;    0x123456789.p09f128;    0x123456789.p09q;   /*  0x123456789.p09f128x; */
-        /* +0x123456789.P+09f16; */  +0x123456789.P+09f32;  +0x123456789.P+09f32x;  +0x123456789.P+09f64;  +0x123456789.P+09f64x;  +0x123456789.P+09w;  +0x123456789.P+09f128;  +0x123456789.P+09Q;  /* +0x123456789.P+09f128x; */
-        /* -0x123456789.P-09f16; */  -0x123456789.P-09f32;  -0x123456789.P-09f32x;  -0x123456789.P-09f64;  -0x123456789.P-09f64x;  -0x123456789.P-09W;  -0x123456789.P-09f128;  -0x123456789.P-09q;  /* -0x123456789.P-09f128x; */
-        /*  0x123456789.p09F16; */    0x123456789.p09F32;    0x123456789.p09F32x;    0x123456789.p09F64;    0x123456789.p09F64x;    0x123456789.p09W;    0x123456789.p09F128;    0x123456789.p09q;   /*  .0123456789p09q; */
-        /* +0x123456789.p+09F16; */  +0x123456789.p+09F32;  +0x123456789.p+09F32x;  +0x123456789.p+09F64;  +0x123456789.p+09F64x;  +0x123456789.p+09w;  +0x123456789.p+09F128;  +0x123456789.p+09Q;  /* +.0123456789p+09Q; */
-        /* -0x123456789.p-09F16; */  -0x123456789.p-09F32;  -0x123456789.p-09F32x;  -0x123456789.p-09F64;  -0x123456789.p-09F64x;  -0x123456789.p-09W;  -0x123456789.p-09F128;  -0x123456789.p-09q;  /* -.0123456789P-09q; */
-        /*  0X.0123456789p09F16; */    0X.0123456789p09F32;    0X.0123456789p09F32x;    0X.0123456789p09F64;    0X.0123456789p09F64x;    0X.0123456789p09W;    0X.0123456789p09F128;    0X.0123456789p09q;   /*  0X.0123456789p09q; */
-        /* +0X.0123456789p+09F16; */  +0X.0123456789p+09F32;  +0X.0123456789p+09F32x;  +0X.0123456789p+09F64;  +0X.0123456789p+09F64x;  +0X.0123456789p+09w;  +0X.0123456789p+09F128;  +0X.0123456789p+09Q;  /* +0X.0123456789p+09Q; */
-        /* -0X.0123456789p-09F16; */  -0X.0123456789p-09F32;  -0X.0123456789p-09F32x;  -0X.0123456789p-09F64;  -0X.0123456789p-09F64x;  -0X.0123456789p-09W;  -0X.0123456789p-09F128;  -0X.0123456789p-09q;  /* -0X.0123456789P-09q; */
-        /*  0x123456789.0123456789P09F16; */    0x123456789.0123456789P09F32;    0x123456789.0123456789P09F32x;    0x123456789.0123456789P09F64;    0x123456789.0123456789P09F64x;    0x123456789.0123456789P09W;    0x123456789.0123456789P09F128;    0x123456789.0123456789P09q;   /*  0x123456789.0123456789P09q; */
-        /* +0x123456789.0123456789P+09F16; */  +0x123456789.0123456789P+09F32;  +0x123456789.0123456789P+09F32x;  +0x123456789.0123456789P+09F64;  +0x123456789.0123456789P+09F64x;  +0x123456789.0123456789P+09w;  +0x123456789.0123456789P+09F128;  +0x123456789.0123456789P+09Q;  /* +0x123456789.0123456789P+09Q; */
-        /* -0x123456789.0123456789p-09F16; */  -0x123456789.0123456789p-09F32;  -0x123456789.0123456789p-09F32x;  -0x123456789.0123456789p-09F64;  -0x123456789.0123456789p-09F64x;  -0x123456789.0123456789p-09W;  -0x123456789.0123456789p-09F128;  -0x123456789.0123456789p-09q;  /* -0x123456789.0123456789p-09q; */
-        /*  0x123456789.0123456789P09F16; */    0x123456789.0123456789P09F32;    0x123456789.0123456789P09F32x;    0x123456789.0123456789P09F64;    0x123456789.0123456789P09F64x;    0x123456789.0123456789P09W;    0x123456789.0123456789P09F128;    0x123456789.0123456789P09q;   /*  0x123456789.0123456789P09q; */
-        /* +0x123456789.0123456789p+09F16; */  +0x123456789.0123456789p+09F32;  +0x123456789.0123456789p+09F32x;  +0x123456789.0123456789p+09F64;  +0x123456789.0123456789p+09F64x;  +0x123456789.0123456789p+09w;  +0x123456789.0123456789p+09F128;  +0x123456789.0123456789p+09Q;  /* +0x123456789.0123456789p+09Q; */
-        /* -0x123456789.0123456789P-09F16; */  -0x123456789.0123456789P-09F32;  -0x123456789.0123456789P-09F32x;  -0x123456789.0123456789P-09F64;  -0x123456789.0123456789P-09F64x;  -0x123456789.0123456789P-09W;  -0x123456789.0123456789P-09F128;  -0x123456789.0123456789P-09q;  /* -0x123456789.0123456789P-09q; */
-#endif // __GNUC_PREREQ(7,0)
 #ifdef __CFA__
 // fixed-size length
 …
         // octal
          01234567_l8;   01234567_l16;   01234567_l32;   01234567_l64;   01234567_l8u;   01234567_ul16;   01234567_l32u;   01234567_ul64;
         +01234567_l8;  +01234567_l16;  +01234567_l32;  +01234567_l64;  +01234567_ul8;  +01234567_ul16;  +01234567_l32u;  +01234567_ul64;
+        +01234567_l8;  +01234567_l16;  +01234567_l32;  +01234567_l64;  +01234567_l8u;  +01234567_ul16;  +01234567_l32u;  +01234567_ul64;
         -01234567_l8;  -01234567_l16;  -01234567_l32;  -01234567_l64;  -01234567_l8u;  -01234567_ul16;  -01234567_l32u;  -01234567_ul64;
 …
         +0X0123456789ABCDEF_l8;  +0X0123456789ABCDEF_l16;  +0X0123456789ABCDEFl32;  +0X0123456789ABCDEFl64;  +0X0123456789ABCDEF_ul8;  +0X0123456789ABCDEF_l16u;  +0X0123456789ABCDEFul32;  +0X0123456789ABCDEFl64u;
         -0X0123456789ABCDEF_l8;  -0X0123456789ABCDEF_l16;  -0X0123456789ABCDEFl32;  -0X0123456789ABCDEFl64;  -0X0123456789ABCDEF_ul8;  -0X0123456789ABCDEF_l16u;  -0X0123456789ABCDEFul32;  -0X0123456789ABCDEFl64u;
+        // floating
+         0123456789.l32;   0123456789.l64;   0123456789.l80;   0123456789.l128;
+        +0123456789.l32;  +0123456789.l64;  +0123456789.l80;  +0123456789.l128;
+        -0123456789.l32;  -0123456789.l64;  -0123456789.l80;  -0123456789.l128;
+         0123456789.e09L32;    0123456789.e09L64;    0123456789.e09L80;    0123456789.e09L128;
+        +0123456789.e+09L32;  +0123456789.e+09L64;  +0123456789.e+09L80;  +0123456789.e+09L128;
+        -0123456789.e-09L32;  -0123456789.e-09L64;  -0123456789.e-09L80;  -0123456789.e-09L128;
+         .0123456789e09L32;    .0123456789e09L64;    .0123456789e09L80;    .0123456789e09L128;
+        +.0123456789E+09L32;  +.0123456789E+09L64;  +.0123456789E+09L80;  +.0123456789E+09L128;
+        -.0123456789E-09L32;  -.0123456789E-09L64;  -.0123456789E-09L80;  -.0123456789E-09L128;
+         0123456789.0123456789L32;       0123456789.0123456789L64;       0123456789.0123456789L80;       0123456789.0123456789L128;
+        +0123456789.0123456789E09L32;   +0123456789.0123456789E09L64;   +0123456789.0123456789E09L80;   +0123456789.0123456789E09L128;
+        -0123456789.0123456789E+09L32;  -0123456789.0123456789E+09L64;  -0123456789.0123456789E+09L80;  -0123456789.0123456789E+09L128;
+         0123456789.0123456789E-09L32;   0123456789.0123456789E-09L64;   0123456789.0123456789E-09L80;   0123456789.0123456789E-09L128;
+x0123456789.p09l32;   0x0123456789.p09l64;   0x0123456789.p09l80;   0x0123456789.p09l128;
+        +0x0123456789.p09l32;  +0x0123456789.p09l64;  +0x0123456789.p09l80;  +0x0123456789.p09l128;
+        -0x0123456789.p09l32;  -0x0123456789.p09l64;  -0x0123456789.p09l80;  -0x0123456789.p09l128;
+x0123456789.p+09l32;   0x0123456789.p+09L64;   0x0123456789.p+09L80;   0x0123456789.p+09L128;
+        +0x0123456789.p-09l32;  +0x0123456789.p-09L64;  +0x0123456789.p-09L80;  +0x0123456789.p-09L128;
+        -0x.0123456789p09l32;   -0x.0123456789p09L64;   -0x.0123456789p09L80;   -0x.0123456789p09L128;
 // char, short, int suffix overloading

tests/loopctrl.cfa

-              r933f32f
+              r6a9d4b4
 // Created On       : Wed Aug  8 18:32:59 2018
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Apr 13 11:03:09 2019
 // Update Count     : 104
+// Last Modified On : Sun Dec 23 23:00:29 2018
+// Update Count     : 79
 //
 …
         for ( i; 5.5 -~ 0.5 ) { sout | i; }                                     sout | nl;
         for ( ui; 2u ~= 10u ~ 2u ) { sout | ui; }                       sout | nl;
         for ( ui; 10u -~= 2u ~ 2u ) { sout | ui; }                      sout | nl | nl;
+        for ( ui; 10u -~= 2u ~ 2u ) { sout | ui; }                      sout | nl | nl | nl;
-        // @ means do nothing
-        for ( i; 1 ~ @ ) {
-          if ( i > 10 ) break;
-                sout | i;
-        }                                                                                                       sout | nl;
-        for ( i; 10 -~ @ ) {
-          if ( i < 0 ) break;
-                sout | i;
-        }                                                                                                       sout | nl;
-        for ( i; 2 ~ @ ~ 2 ) {
-          if ( i > 10 ) break;
-                sout | i;
-        }                                                                                                       sout | nl;
-        for ( i; 2.1 ~ @ ~ @ ) {
-          if ( i > 10.5 ) break;
-                sout | i;
-                i += 1.7;
-        }                                                                                                       sout | nl;
-        for ( i; 10 -~ @ ~ 2 ) {
-          if ( i < 0 ) break;
-                sout | i;
-        }                                                                                                       sout | nl;
-        for ( i; 12.1 ~ @ ~ @ ) {
-          if ( i < 2.5 ) break;
-                sout | i;
-                i -= 1.7;
-        }                                                                                                       sout | nl | nl;
         enum { N = 10 };
         for ( N ) { sout | "N"; }                                                       sout | nl;
         for ( i; N ) { sout | i; }                                                      sout | nl;
         for ( i; N -~ 0 ) { sout | i; }                                         sout | nl | nl;
+        for ( i; N -~ 0 ) { sout | i; }                                         sout | nl | nl | nl;
         const int start = 3, comp = 10, inc = 2;
         for ( i; start ~ comp ~ inc + 1 ) { sout | i; }         sout | nl | nl;
+        sout | nl;
         for ( S s = (S){0}; s < (S){10,10}; s += (S){1} ) { sout | s; } sout | nl;
         for ( s; (S){10,10} ) { sout | s; } sout | nl;
 …
         for ( s; (S){10,10} -~ (S){0} ~ (S){1} ) { sout | s; } sout | nl;
         for ( s; (S){10,10} -~= (S){0} ) { sout | s; }           sout | nl;
+        for ( s; (S){10,10} -~= (S){0} ~ (S){1} ) { sout | s; } sout | nl | nl;
+        for ( i; 10 : j; -5 ~ @ ) { sout | i | j; } sout | nl;
+        for ( i; 10 : j; -5 -~ @ ) { sout | i | j; } sout | nl;
+        for ( i; 10 : j; -5 ~ @ ~ 2 ) { sout | i | j; } sout | nl;
+        for ( i; 10 : j; -5 -~ @ ~ 2 ) { sout | i | j; } sout | nl | nl;
+        for ( j; -5 ~ @ : i; 10 ) { sout | i | j; } sout | nl;
+        for ( j; -5 -~ @ : i; 10 ) { sout | i | j; } sout | nl;
+        for ( j; -5 ~ @ ~ 2 : i; 10 ) { sout | i | j; } sout | nl;
+        for ( j; -5 -~ @ ~ 2 : i; 10 ) { sout | i | j; } sout | nl | nl;
+        for ( j; -5 -~ @ ~ 2 : i; 10 : k; 1.5 ~ @ ) { sout | i | j | k; } sout | nl;
+        for ( j; -5 -~ @ ~ 2 : k; 1.5 ~ @ : i; 10 ) { sout | i | j | k; } sout | nl;
+        for ( k; 1.5 ~ @ : j; -5 -~ @ ~ 2 : i; 10 ) { sout | i | j | k; } sout | nl;
+        for ( s; (S){10,10} -~= (S){0} ~ (S){1} ) { sout | s; } sout | nl;
+}

tests/math1.cfa

-              r933f32f
+              r6a9d4b4
 // Created On       : Fri Apr 22 14:59:21 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Mon Mar 25 22:56:47 2019
 // Update Count     : 109
+// Last Modified On : Wed Dec 12 16:28:49 2018
+// Update Count     : 89
 //
 …
         unsigned int e = 2;
     b \= e;
+    sout | b | "\\" | e | "= " | b \ e;
+    sout | 'a' \ 3 | 2 \ 8 | 4 \ 3 | -4 \ 3 | 4 \ -3 | -4 \ -3;
+        sout | 4.0 \ -3 | -4.0 \ -3 | 4.0 \ 2.1 | (1.0f+2.0fi) \ (3.0f+2.0fi);
+    sout | "\\" | b | b \ e;
+    sout | "\\" | 'a' \ 3u | 2 \ 8u | 4 \ 3u | -4 \ 3u | nonl;
         sout | 4 \ -3 | -4 \ -3 | 4.0 \ 2.1 | (1.0f+2.0fi) \ (3.0f+2.0fi);
-        struct S { int i; };
-        double ?*?( double d, S s ) { return d * s.i; }
-        double ?/?( double d, S s ) { return d / s.i; }
-        S ?\?( S s, unsigned long y ) { return (S){ s.i \ y }; }
-        ofstream & ?|?( ofstream & os, S s ) { return os | s.i; }
-        void ?|?( ofstream & os, S s ) { (ofstream &)(os | s); nl( os ); }
-        S s = { 4 };
-        S x = s \ 2;
-        sout | x;
-        sout | s.i | s \ 2u;
 } // main

tests/numericConstants.cfa

-              r933f32f
+              r6a9d4b4
 // Created On       : Wed May 24 22:10:36 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Tue Feb  5 08:58:16 2019
 // Update Count     : 5
+// Last Modified On : Tue Nov  6 17:59:53 2018
+// Update Count     : 3
 //
 …
 // Local Variables: //
 // tab-width: 4 //
 // compile-command: "cfa numericConstants.cfa" //
+// compile-command: "cfa minmax.cfa" //
 // End: //

tests/pybin/settings.py

-              r933f32f
+              r6a9d4b4
+from __future__ import print_function
 import os
-import subprocess
 import sys
 from . import tools
+import tools
 try :
 …
         def __init__(self, arch):
                 try:
                         canonical_host = Architecture.make_canonical( config.HOSTARCH )
+                        canonical_host = Architecture.makeCanonical( config.HOSTARCH )
                 except KeyError:
                         print("Unkown host architecture %s" % config.HOSTARCH, file=sys.stderr)
 …
                 if arch:
                         try:
                                 arch = Architecture.make_canonical( arch )
+                                arch = Architecture.makeCanonical( arch )
                         except KeyError:
                                 print("Unkown architecture %s" % arch, file=sys.stderr)
 …
         @classmethod
         def make_canonical(_, arch):
+        def makeCanonical(_, arch):
                 return Architecture.KnownArchitectures[arch]
 …
         def __init__(self, value):
                 self.string = "debug" if value else "no debug"
                 self.flags  = """DEBUG_FLAGS=%s""" % ("-debug -O0" if value else "-nodebug -O2")
+                self.flags  = """DEBUG_FLAGS="%s" """ % ("-debug -O0" if value else "-nodebug -O2")
 class Install:
         def __init__(self, value):
                 self.string = "installed" if value else "in-tree"
                 self.flags  = """INSTALL_FLAGS=%s""" % ("" if value else "-in-tree")
+                self.flags  = """INSTALL_FLAGS="%s" """ % ("" if value else "-in-tree")
 class Timeouts:
 …
         global install
         global timeout
-        global output_width
+        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
+        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)
 def update_make_cmd(force, jobs):
+def updateMakeCmd(force, jobs):
         global make
         make = ['make'] if not force else ['make', "-j%i" % jobs]
+        make = "make" if not force else ("make -j%i" % jobs)
 def validate():
         errf = os.path.join(BUILDDIR, ".validate.err")
         make_ret, out = tools.make( ".validate", error_file = errf, output=subprocess.DEVNULL, error=subprocess.DEVNULL )
+        make_ret, _ = tools.make( ".validate", error_file = errf, redirects  = "2> /dev/null 1> /dev/null", )
         if make_ret != 0:
                 with open (errf, "r") as myfile:
 …
         tools.rm(errf)
-def prep_output(tests):
-        global output_width
-        output_width = max(map(lambda t: len(t.target()), tests))

tests/pybin/test_run.py

-              r933f32f
+              r6a9d4b4
 import pybin.settings
+import datetime
+from string import Template
+class DeltaTemplate(Template):
+    delimiter = "%"
+def strfdelta(tdelta, fmt):
+    d["H"], rem = divmod(tdelta.seconds, 3600)
+    d["M"], d["S"] = divmod(rem, 60)
+    t = DeltaTemplate(fmt)
+    return t.substitute(**d)
 # Test class that defines what a test is

tests/pybin/tools.py

-              r933f32f
+              r6a9d4b4
+from __future__ import print_function
 import __main__
 import argparse
-import contextlib
 import fileinput
 import multiprocessing
 …
 import signal
 import stat
-import subprocess
 import sys
-import tempfile
 import time
-import types
 from pybin import settings
+from subprocess import Popen, PIPE, STDOUT
 ################################################################################
 …
 # helper functions to run terminal commands
+def sh(*cmd, timeout = False, output = None, input = None, error = subprocess.STDOUT):
+        cmd = list(cmd)
+def sh(cmd, print2stdout = True, input = None):
+        # add input redirection if needed
+        if input and os.path.isfile(input):
+                cmd += " < %s" % input
         # 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)
+                print("cmd: %s" % 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,
+                                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)
+        # otherwise create a pipe and run the desired command
+        else :
+                proc = Popen(cmd, stdout=None if print2stdout else PIPE, stderr=STDOUT, shell=True)
+                out, err = proc.communicate()
+                return proc.returncode, out
 def is_ascii(fname):
 …
                 return False
         code, out = sh("file %s" % fname, output=subprocess.PIPE)
+        code, out = sh("file %s" % fname, print2stdout = False)
         if code != 0:
                 return False
 …
         return match.group(1).startswith("ASCII text")
-def is_exe(fname):
-        return os.path.isfile(fname) and os.access(fname, os.X_OK)
-def openfd(file, mode, exitstack, checkfile):
-        if not file:
-                return file
-        if isinstance(file, int):
-                return file
-        if checkfile and not os.path.isfile(file):
-                return None
-        file = open(file, mode)
-        exitstack.push(file)
-        return file
 # Remove 1 or more files silently
 def rm( files ):
+        if isinstance(files, str ): files = [ files ]
+        for file in files:
+                sh( 'rm', '-f', file, output=subprocess.DEVNULL, error=subprocess.DEVNULL )
+        if isinstance( files, basestring ):
+                sh("rm -f %s > /dev/null 2>&1" % files )
+        else:
+                for file in files:
+                        sh("rm -f %s > /dev/null 2>&1" % file )
 # Create 1 or more directory
 def mkdir( files ):
         if isinstance(files, str ): files = [ files ]
         for file in files:
                 p = os.path.normpath( file )
                 d = os.path.dirname ( p )
                 sh( 'mkdir', '-p', d, output=subprocess.DEVNULL, error=subprocess.DEVNULL )
+        if isinstance( files, basestring ):
+                sh("mkdir -p %s" % os.path.dirname(files) )
+        else:
+                for file in files:
+                        sh("mkdir -p %s" % os.path.dirname(file) )
 …
 # diff two files
 def diff( lhs, rhs ):
+        # diff the output of the files
+        diff_cmd = ("diff --text "
+#                               "--ignore-all-space "
+#                               "--ignore-blank-lines "
+                                "--old-group-format='\t\tmissing lines :\n"
+                                "%%<' \\\n"
+                                "--new-group-format='\t\tnew lines :\n"
+                                "%%>' \\\n"
+                                "--unchanged-group-format='%%=' \\"
+                                "--changed-group-format='\t\texpected :\n"
+                                "%%<"
+                                "\t\tgot :\n"
+                                "%%>\n' \\\n"
+                                "--new-line-format='\t\t%%dn\t%%L' \\\n"
+                                "--old-line-format='\t\t%%dn\t%%L' \\\n"
+                                "--unchanged-line-format='' \\\n"
+                                "%s %s")
         # fetch return code and error from the diff command
+        return sh(
+                '''diff''',
+                '''--text''',
+                '''--old-group-format=\t\tmissing lines :\n%<''',
+                '''--new-line-format=\t\t%dn\t%L''',
+                '''--new-group-format=\t\tnew lines : \n%>''',
+                '''--old-line-format=\t\t%dn\t%L''',
+                '''--unchanged-group-format=%=''',
+                '''--changed-group-format=\t\texpected :\n%<\t\tgot :\n%>''',
+                '''--unchanged-line-format=''',
+                lhs,
+                rhs,
+                output=subprocess.PIPE
+        )
+        return sh(diff_cmd % (lhs, rhs), False)
 # call make
 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.make,
                 '-s' if silent else None,
+def make(target, flags = '', redirects = '', error_file = None, silent = False):
+        test_param = """test="%s" """ % (error_file) if error_file else ''
+        cmd = ' '.join([
+                settings.make,
+                '-s' if silent else '',
                 test_param,
                 settings.arch.flags,
 …
                 settings.install.flags,
                 flags,
                 target
+        ]
         cmd = [s for s in cmd if s]
         return sh(*cmd, output=output, error=error)
+                target,
+                redirects
+        ])
+        return sh(cmd)
 def which(program):
+    import os
+    def is_exe(fpath):
+        return os.path.isfile(fpath) and os.access(fpath, os.X_OK)
     fpath, fname = os.path.split(program)
     if fpath:
 …
     return None
+@contextlib.contextmanager
+def tempdir():
+        cwd = os.getcwd()
+        with tempfile.TemporaryDirectory() as temp:
+                os.chdir(temp)
+                try:
+                        yield temp
+                finally:
+                        os.chdir(cwd)
+def run(exe, output, input):
+        ret, _ = sh("timeout %d %s > %s 2>&1" % (settings.timeout.single, exe, output), input = input)
+        return ret
 ################################################################################
 …
 # move a file
 def mv(source, dest):
         ret, _ = sh("mv", source, dest)
+        ret, _ = sh("mv %s %s" % (source, dest))
         return ret
 # cat one file into the other
 def cat(source, dest):
         ret, _ = sh("cat", source, output=dest)
+        ret, _ = sh("cat %s > %s" % (source, dest))
         return ret
 …
 # helper function to check if a files contains only a specific string
 def file_contains_only(file, text) :
+def fileContainsOnly(file, text) :
         with open(file) as f:
                 ff = f.read().strip()
                 result = ff == text.strip()
+                return result
+                return result;
+# check whether or not a file is executable
+def fileIsExecutable(file) :
+        try :
+                fileinfo = os.stat(file)
+                return bool(fileinfo.st_mode & stat.S_IXUSR)
+        except Exception as inst:
+                print(type(inst))    # the exception instance
+                print(inst.args)     # arguments stored in .args
+                print(inst)
+                return False
 # transform path to canonical form
 def canonical_path(path):
+def canonicalPath(path):
         abspath = os.path.abspath(__main__.__file__)
         dname = os.path.dirname(abspath)
 …
 # compare path even if form is different
 def path_cmp(lhs, rhs):
         return canonical_path( lhs ) == canonical_path( rhs )
+def pathCmp(lhs, rhs):
+        return canonicalPath( lhs ) == canonicalPath( rhs )
 # walk all files in a path
+def path_walk( op ):
+        dname = settings.SRCDIR
+        for dirname, _, names in os.walk(dname):
+def pathWalk( op ):
+        def step(_, dirname, names):
                 for name in names:
                         path = os.path.join(dirname, name)
                         op( path )
+        # Start the walk
+        dname = settings.SRCDIR
+        os.path.walk(dname, step, '')
 ################################################################################
 #               system
 ################################################################################
 # count number of jobs to create
 def job_count( options, tests ):
+def jobCount( options, tests ):
         # check if the user already passed in a number of jobs for multi-threading
         if not options.jobs:
 …
         return min( options.jobs, len(tests) ), force
+# setup a proper processor pool with correct signal handling
+def setupPool(jobs):
+        original_sigint_handler = signal.signal(signal.SIGINT, signal.SIG_IGN)
+        pool = multiprocessing.Pool(jobs)
+        signal.signal(signal.SIGINT, original_sigint_handler)
+        return pool
+# handle signals in scope
+class SignalHandling():
+        def __enter__(self):
+                # enable signal handling
+                signal.signal(signal.SIGINT, signal.SIG_DFL)
+        def __exit__(self, type, value, traceback):
+                # disable signal handling
+                signal.signal(signal.SIGINT, signal.SIG_IGN)
 # enable core dumps for all the test children
 resource.setrlimit(resource.RLIMIT_CORE, (resource.RLIM_INFINITY, resource.RLIM_INFINITY))
 …
                 return False
         raise argparse.ArgumentTypeError(msg)
+        return False
 def fancy_print(text):
         column = which('column')
         if column:
+                subprocess.run(column, input=bytes(text + "\n", "UTF-8"))
+                cmd = "%s 2> /dev/null" % column
+                proc = Popen(cmd, stdin=PIPE, stderr=None, shell=True)
+                proc.communicate(input=text + "\n")
         else:
                 print(text)
+def core_info(path):
+        if not os.path.isfile(path):
+                return 1, "ERR Executable path is wrong"
+def coreInfo(path):
         cmd   = os.path.join(settings.SRCDIR, "pybin/print-core.gdb")
         if not os.path.isfile(cmd):
                 return 1, "ERR Printing format for core dumps not found"
+        core  = os.path.join(os.getcwd(), "core" )
+        dname = os.path.dirname(path)
+        core  = os.path.join(dname, "core" )
+        if not os.path.isfile(path):
+                return 1, "ERR Executable path is wrong"
         if not os.path.isfile(core):
                 return 1, "ERR No core dump"
         return sh('gdb', '-n', path, core, '-batch', '-x', cmd, output=subprocess.PIPE)
+        return sh("gdb -n %s %s -batch -x %s" % (path, core, cmd), print2stdout=False)
 class Timed:

tests/raii/.expect/ctor-autogen-ERR1.txt

-              r933f32f
+              r6a9d4b4
 raii/ctor-autogen.cfa:102:1 error: Unique best alternative includes deleted identifier in Generated Cast of:
+raii/ctor-autogen.cfa:102:1 error: Unique best alternative includes deleted identifier in Cast of:
   Application of
     Deleted Expression
 …
             ... to arguments
               Generated Cast of:
+              Cast of:
                 Member Expression, with field:
                   x: signed int
                 ... from aggregate:
                   Generated Cast of:
+                  Cast of:
                     Variable Expression: m: reference to instance of struct Managed with body 1
                   ... to:
 …
               ... to:
                 reference to signed int
               Generated Cast of:
+              Cast of:
                 constant expression (0 0: zero_t)
               ... to:
 …
   ... to arguments
     Generated Cast of:
+    Cast of:
       Variable Expression: x: instance of struct Managed with body 1
     ... to:

tests/raii/init_once.cfa

-              r933f32f
+              r6a9d4b4
 // Created On       : Tue Jun 14 15:43:35 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Mar 22 13:41:26 2019
 // Update Count     : 4
+// Last Modified On : Sat Jul  9 11:30:29 2016
+// Update Count     : 3
 //
 …
 // Local Variables: //
 // tab-width: 4 //
 // compile-command: "cfa init_once.cfa" //
+// compile-command: "cfa init_once.c" //
 // End: //

tests/rational.cfa

-              r933f32f
+              r6a9d4b4
 // Created On       : Mon Mar 28 08:43:12 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed Mar 27 07:37:17 2019
 // Update Count     : 80
+// Last Modified On : Tue Dec  4 21:46:42 2018
+// Update Count     : 69
 //
 …
 #include <fstream.hfa>
+// UNNECESSARY, FIX ME
+void ?{}( int & this ) { this = 0; }
+void ?{}( int & this, zero_t ) { this = 0; }
+void ?{}( int & this, one_t ) { this = 1; }
 double convert( int i ) { return (double)i; }
 int convert( double d ) { return (int)d; }
 …
         sout | a * b;
         sout | a / b;
-//      sout | a \ 2 | b \ 2; // FIX ME
-//      sout | a \ -2 | b \ -2;
         sout | "conversion";

tests/sum.cfa

-              r933f32f
+              r6a9d4b4
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sun May 19 11:21:02 2019
 // Update Count     : 330
+// Last Modified On : Sun Dec 23 23:00:38 2018
+// Update Count     : 287
 //
 #include <fstream.hfa>
 #include <stdlib.hfa>
+void ?{}( int & c, zero_t ) { c = 0; }                                  // not in prelude
 trait sumable( otype T ) {
 …
 T sum( size_t size, T a[] ) {
         T total = 0;                                                                            // initialize by 0 constructor
         for ( i; size )
+        for ( size_t i = 0; i < size; i += 1 )
                 total += a[i];                                                                  // select appropriate +
         return total;
 } // sum
+// Not in prelude.
+unsigned char ?+?( unsigned char t1, unsigned char t2 ) { return (int)t1 + t2; } // cast forces integer addition, otherwise recursion
+unsigned char ?+=?( unsigned char & t1, unsigned char t2 ) { t1 = t1 + t2; return t1; }
+unsigned char ++?( unsigned char & t ) { t += 1; return t; }
+unsigned char ?++( unsigned char & t ) { unsigned char temp = t; t += 1; return temp; }
+// Not in prelude.
+void ?{}( unsigned char & c, zero_t ) { c = 0; }
+void ?{}( float & f, zero_t ) { f = 0.0; }
+void ?{}( double & d, zero_t ) { d = 0.0; }
 int main( void ) {
         const int low = 5, High = 15, size = High - low;
         signed char s = 0, a[size], v = (char)low;
         for ( int i = 0; i < size; i += 1, v += 1hh ) {
+        unsigned char s = 0, a[size], v = (char)low;
+        for ( int i = 0; i < size; i += 1, v += 1 ) {
                 s += v;
                 a[i] = v;
         } // for
         sout | "sum from" | low | "to" | High | "is"
+                 | sum( size, (signed char *)a ) | ", check" | (signed char)s;
+        unsigned char s = 0, a[size], v = low;
+        for ( int i = 0; i < size; i += 1, v += 1hhu ) {
+                s += (unsigned char)v;
+                a[i] = (unsigned char)v;
+        } // for
+        sout | "sum from" | low | "to" | High | "is"
+                 | sum( size, (unsigned char *)a ) | ", check" | (unsigned char)s;
+        short int s = 0, a[size], v = low;
+        for ( int i = 0; i < size; i += 1, v += 1h ) {
+                s += (short int)v;
+                a[i] = (short int)v;
+        } // for
+        sout | "sum from" | low | "to" | High | "is"
+                 | sum( size, (short int *)a ) | ", check" | (short int)s;
+                 | sum( size, (unsigned char *)a ) | ", check" | (int)s;
         int s = 0, a[size], v = low;

tests/test.py

-              r933f32f
+              r6a9d4b4
+#!/usr/bin/python3
+#!/usr/bin/python
+from __future__ import print_function
 from pybin.tools import *
 …
 import re
 import sys
-import tempfile
 import time
 …
 ################################################################################
 def find_tests():
+def findTests():
         expected = []
         def match_test(path):
+        def matchTest(path):
                 match = re.search("^%s\/([\w\/\-_]*).expect\/([\w\-_]+)(\.[\w\-_]+)?\.txt$" % settings.SRCDIR, path)
                 if match :
 …
                                 expected.append(test)
         path_walk( match_test )
+        pathWalk( matchTest )
         return expected
 # reads the directory ./.expect and indentifies the tests
 def list_tests( includes, excludes ):
+def listTests( includes, excludes ):
         # tests directly in the .expect folder will always be processed
         test_list = find_tests()
+        test_list = findTests()
         # if we have a limited number of includes, filter by them
 …
 # from the found tests, filter all the valid tests/desired tests
 def valid_tests( options ):
+def validTests( options ):
         tests = []
 …
         if options.regenerate_expected :
                 for testname in options.tests :
                         testname = canonical_path( testname )
+                        testname = canonicalPath( testname )
                         if Test.valid_name(testname):
                                 found = [test for test in all_tests if canonical_path( test.target() ) == testname]
+                                found = [test for test in allTests if canonicalPath( test.target() ) == testname]
                                 tests.append( found[0] if len(found) == 1 else Test.from_target(testname) )
                         else :
 …
                 # otherwise we only need to validate that all tests are present in the complete list
                 for testname in options.tests:
                         test = [t for t in all_tests if path_cmp( t.target(), testname )]
+                        test = [t for t in allTests if pathCmp( t.target(), testname )]
                         if test :
 …
 # parses the option
 def parse_args():
+def getOptions():
         # create a parser with the arguments for the tests script
         parser = argparse.ArgumentParser(description='Script which runs cforall tests')
 …
                 print('ERROR: invalid arguments', file=sys.stderr)
                 parser.print_help(sys.stderr)
                 sys.exit(1)
+                sys.exit(1)
         # script must have at least some tests to run or be listing
 …
         # check that exactly one of the booleans is set to true
         if not sum( (listing, all_tests, some_tests, some_dirs) ) > 0 :
                 print('''ERROR: must have option '--all', '--list', '--include', '-I' or non-empty test list''', file=sys.stderr)
+                print('ERROR: must have option \'--all\', \'--list\', \'--include\', \'-I\' or non-empty test list', file=sys.stderr)
                 parser.print_help()
                 sys.exit(1)
 …
         return val == 0 or settings.dry_run
+def no_rule(file, target):
+        return not settings.dry_run and file_contains_only(file, "make: *** No rule to make target `%s'.  Stop." % target)
+def isExe(file):
+        return settings.dry_run or fileIsExecutable(file)
+def noRule(file, target):
+        return not settings.dry_run and fileContainsOnly(file, "make: *** No rule to make target `%s'.  Stop." % target)
 # logic to run a single test and return the result (No handling of printing or other test framework logic)
 …
         # build, skipping to next test on error
         with Timed() as comp_dur:
+                make_ret, _ = make( test.target(), output=subprocess.DEVNULL, error=out_file, error_file = err_file )
+                make_ret, _ = make( test.target(),      redirects  = ("2> %s 1> /dev/null" % out_file), error_file = err_file )
+        # if the make command succeds continue otherwise skip to diff
         run_dur = None
+        # run everything in a temp directory to make sure core file are handled properly
+        with tempdir():
+                # 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=out_file, input=in_file, timeout=True)
+                                else :
+                                        # simply cat the result into the output
+                                        retcode = cat(exe_file, out_file)
+                else:
+                        retcode = mv(err_file, out_file)
+                if success(retcode):
+                        if settings.generating :
+                                # if we are ounly generating the output we still need to check that the test actually exists
+                                if no_rule(out_file, test.target()) :
+                                        retcode = 1
+                                        error = "\t\tNo make target for test %s!" % test.target()
+                                        rm(out_file)
+                                else:
+                                        error = None
+        if success(make_ret):
+                with Timed() as run_dur:
+                        if isExe(exe_file):
+                                # run test
+                                retcode = run(exe_file, out_file, in_file)
                         else :
+                                # fetch return code and error from the diff command
+                                retcode, error = diff(cmp_file, out_file)
+                else:
+                        with open (out_file, "r") as myfile:
+                                error = myfile.read()
+                        ret, info = core_info(exe_file)
+                        error = error + info if error else info
+                                # simply cat the result into the output
+                                retcode = cat(exe_file, out_file)
+        else:
+                retcode = mv(err_file, out_file)
+        if success(retcode):
+                if settings.generating :
+                        # if we are ounly generating the output we still need to check that the test actually exists
+                        if noRule(out_file, test.target()) :
+                                retcode = 1
+                                error = "\t\tNo make target for test %s!" % test.target()
+                                rm(out_file)
+                        else:
+                                error = None
+                else :
+                        # fetch return code and error from the diff command
+                        retcode, error = diff(cmp_file, out_file)
+        else:
+                with open (out_file, "r") as myfile:
+                        error = myfile.read()
+                ret, info = coreInfo(exe_file)
+                error = error + info
 …
 # run a single test and handle the errors, outputs, printing, exception handling, etc.
 def run_test_worker(t) :
+        try :
+        with SignalHandling():
                 # print formated name
                 name_txt = '{0:{width}}  '.format(t.target(), width=settings.output_width)
+                name_txt = "%24s  " % t.name
                 retcode, error, duration = run_single_test(t)
 …
                 #print result with error if needed
                 text = '\t' + name_txt + result_txt
+                text = name_txt + result_txt
                 out = sys.stdout
                 if error :
                         text = text + '\n' + error
+                        text = text + "\n" + error
                         out = sys.stderr
 …
                 sys.stderr.flush()
+                return retcode != TestResult.SUCCESS
+        except KeyboardInterrupt:
+                False
+        return retcode != TestResult.SUCCESS
 # run the given list of tests with the given parameters
 def run_tests(tests, jobs) :
         # clean the sandbox from previous commands
         make('clean', output=subprocess.DEVNULL, error=subprocess.DEVNULL)
+        make('clean', redirects = '> /dev/null 2>&1')
         # create the executor for our jobs and handle the signal properly
         pool = multiprocessing.Pool(jobs)
+        pool = setupPool(jobs)
         # for each test to run
 …
         # clean the workspace
         make('clean', output=subprocess.DEVNULL, error=subprocess.DEVNULL)
+        make('clean', redirects = '> /dev/null 2>&1')
         for failed in results:
 …
         # parse the command line arguments
         options = parse_args()
+        options = getOptions()
         # init global settings
 …
         # fetch the liest of all valid tests
         all_tests = list_tests( options.include, options.exclude )
+        allTests = listTests( options.include, options.exclude )
         # if user wants all tests than no other treatement of the test list is required
         if options.all or options.list or options.list_comp or options.include :
                 tests = all_tests
+                tests = allTests
         #otherwise we need to validate that the test list that was entered is valid
         else :
                 tests = valid_tests( options )
+                tests = validTests( options )
         # make sure we have at least some test to run
 …
         elif options.list :
                 print("Listing for %s:%s"% (settings.arch.string, settings.debug.string))
                 fancy_print("\n".join(map(lambda t: t.toString(), tests)))
+                fancy_print("\n".join(map(lambda t: "%s" % (t.toString()), tests)))
         else :
                 # check the build configuration works
-                settings.prep_output(tests)
                 settings.validate()
+                options.jobs, forceJobs = job_count( options, tests )
+                settings.update_make_cmd(forceJobs, options.jobs)
+                print('%s %i tests on %i cores (%s:%s)' % (
+                        'Regenerating' if settings.generating else 'Running',
+                        len(tests),
+                        options.jobs,
+                options.jobs, forceJobs = jobCount( options, tests )
+                settings.updateMakeCmd(forceJobs, options.jobs)
+                print('%s (%s:%s) on %i cores' % (
+                        'Regenerate tests' if settings.generating else 'Running',
                         settings.arch.string,
+                        settings.debug.string
+                        settings.debug.string,
+                        options.jobs
                 ))

tests/warnings/.expect/self-assignment.txt

-              r933f32f
+              r6a9d4b4
 warnings/self-assignment.cfa:29:1 warning: self assignment of expression: Generated Cast of:
+warnings/self-assignment.cfa:29:1 warning: self assignment of expression: Cast of:
   Variable Expression: j: signed int
 ... to:
   reference to signed int
 warnings/self-assignment.cfa:30:1 warning: self assignment of expression: Generated Cast of:
+warnings/self-assignment.cfa:30:1 warning: self assignment of expression: Cast of:
   Variable Expression: s: instance of struct S with body 1
 ... to:
   reference to instance of struct S with body 1
 warnings/self-assignment.cfa:31:1 warning: self assignment of expression: Generated Cast of:
+warnings/self-assignment.cfa:31:1 warning: self assignment of expression: Cast of:
   Member Expression, with field:
     i: signed int
 …
 ... to:
   reference to signed int
 warnings/self-assignment.cfa:32:1 warning: self assignment of expression: Generated Cast of:
+warnings/self-assignment.cfa:32:1 warning: self assignment of expression: Cast of:
   Member Expression, with field:
     i: signed int

tests/warnings/self-assignment.cfa

-              r933f32f
+              r6a9d4b4
 // Author           : Rob Schluntz
 // Created On       : Thu Mar 1 13:53:57 2018
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed Feb 20 07:56:17 2019
 // Update Count     : 3
+// Last Modified By : Rob Schluntz
+// Last Modified On : Thu Mar 1 13:53:57 2018
+// Update Count     : 2
 //
 struct S {
         int i;
+  int i;
 };
 struct T {
         S s;
+  S s;
 };
 int main() {
         int j = 0;
         S s = { 0 };
         T t = { { 0 } };
+  int j = 0;
+  S s = { 0 };
+  T t = { { 0 } };
         j = j;
         s = s;
         s.i = s.i;
         t.s.i = t.s.i;
+  j = j;
+  s = s;
+  s.i = s.i;
+  t.s.i = t.s.i;
+}

tools/Makefile.in

r933f32f	r6a9d4b4
194	194	DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)
195	195	ACLOCAL = @ACLOCAL@
	196	ALLOCA = @ALLOCA@
196	197	AMTAR = @AMTAR@
197	198	AM_DEFAULT_VERBOSITY = @AM_DEFAULT_VERBOSITY@

tools/PrettyGitLogs.sh

r933f32f	r6a9d4b4
27	27	git rev-list --format=short ${GitOldRef}...${GitNewRef} > ${GIT_LOG}
28	28
29		git diff --stat ~~--color ${GitNewRef} ${GitOldRef} \| sed -e 's/\[32m/<span style\=\"color\: \#00AA00\;\">/g' -e 's/\[31m/<span style\=\"color\: \#AA0000\;\">/g' -e 's/\[m/<\/span>/g'~~ > ${GIT_DIFF}
	29	git diff --stat ${GitNewRef} ${GitOldRef} > ${GIT_DIFF}

tools/prettyprinter/Makefile.in

r933f32f	r6a9d4b4
223	223	DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)
224	224	ACLOCAL = @ACLOCAL@
	225	ALLOCA = @ALLOCA@
225	226	AMTAR = @AMTAR@
226	227	AM_DEFAULT_VERBOSITY = @AM_DEFAULT_VERBOSITY@

Context Navigation

Changes in / [933f32f:6a9d4b4]

Legend: