Diff [34b42682a27d035cf271583e53b685bd4ba02119:24d6572fc571b2a894d56a9335edd57899c448c0] for / – Cforall

Jenkins/FullBuild

-              r34b4268
+              r24d6572
                                         gcc_08_x86_new: { trigger_build( 'gcc-10',  'x86', false ) },
                                         gcc_07_x86_new: { trigger_build( 'gcc-9',   'x86', false ) },
+                                        gcc_11_x64_new: { trigger_build( 'gcc-11',  'x64', false ) },
                                         gcc_10_x64_new: { trigger_build( 'gcc-10',  'x64', false ) },
                                         gcc_09_x64_new: { trigger_build( 'gcc-9',   'x64', false ) },
                                         gcc_08_x64_new: { trigger_build( 'gcc-8',   'x64', false ) },
                                         gcc_07_x64_new: { trigger_build( 'gcc-7',   'x64', false ) },
                                         gcc_06_x64_new: { trigger_build( 'gcc-6',   'x64', false ) },
+                                        // gcc_06_x64_new: { trigger_build( 'gcc-6',   'x64', false ) },
                                         clang_x64_new:  { trigger_build( 'clang',   'x64', true  ) },
+                                )
 …
+        }
         //If an exception is caught we need to change the status and remember to
         //attach the build log to the email
+        // If an exception is caught we need to change the status and remember to
+        // attach the build log to the email
         catch (Exception caughtError) {
                 echo('error caught')
 …
         // Run the build
         // Don't propagate, it doesn't play nice with our email setup
         def result = build job: 'Cforall/master',               \
+        def result = build job: 'Cforall/master',                       \
                 parameters: [                                           \
                         [$class: 'StringParameterValue',                \
 …
                         [$class: 'BooleanParameterValue',               \
                           name: 'NewAST',                               \
                           value: true],                                         \
+                          value: true],                                 \
                         [$class: 'BooleanParameterValue',               \
                           name: 'RunAllTests',                          \
                           value: true],                                         \
+                          value: true],                                 \
                         [$class: 'BooleanParameterValue',               \
                           name: 'RunBenchmark',                         \
                           value: true],                                         \
+                          value: true],                                 \
                         [$class: 'BooleanParameterValue',               \
                           name: 'BuildDocumentation',           \
+                          name: 'BuildDocumentation',                   \
                           value: doc],                                  \
                         [$class: 'BooleanParameterValue',               \
                           name: 'Publish',                              \
                           value: true],                                         \
+                          value: true],                                 \
                         [$class: 'BooleanParameterValue',               \
                           name: 'Silent',                               \
                           value: true],                                         \
                 ],                                                              \
+                          value: true],                                 \
+                ],                                                      \
                 propagate: false
 …
 def trigger_dist(String commitId, String buildNum) {
         def result = build job: 'Cforall_Distribute_Ref',       \
+        def result = build job: 'Cforall_Distribute_Ref',               \
                 parameters: [                                           \
                         string(name: 'GitRef', value: commitId),        \
                         string(name: 'Build' , value: buildNum) \
                 ],                                                              \
+                        string(name: 'Build' , value: buildNum)         \
+                ],                                                      \
                 propagate: false

Jenkins/Promote

-              r34b4268
+              r24d6572
                 dir (BuildDir) {
                     sh 'rm -rf *'
                         sshagent (credentials: ['github_key_jun1']) {
+                        sshagent (credentials: ['git_key_mar27']) {
                                 sh "git clone --bare ${RemoteRepo} repo"
+                        }
 …
                         sh "git status"
                         sh "git diff-index --quiet HEAD || git commit -m 'Push from build machine: ${name}'"
                         sshagent (credentials: ['github_key_jun1']) {
+                        sshagent (credentials: ['git_key_mar27']) {
                                 sh "git push origin master"
+                        }

Jenkinsfile

-              r34b4268
+              r24d6572
                         dir (BuildDir) {
                                 //Run the tests from the tests directory
                                 sh """make ${jopt} --no-print-directory -C tests timeouts="--timeout=600 --global-timeout=14400" all-tests debug=yes archiveerrors=${BuildDir}/tests/crashes/full-debug"""
+                                sh """make ${jopt} --no-print-directory -C tests timeout=600 global-timeout=14400 tests debug=yes archive-errors=${BuildDir}/tests/crashes/full-debug"""
+                        }
+                }
 …
                         dir (BuildDir) {
                                 //Run the tests from the tests directory
                                 sh """make ${jopt} --no-print-directory -C tests timeouts="--timeout=600 --global-timeout=14400" all-tests debug=no  archiveerrors=${BuildDir}/tests/crashes/full-nodebug"""
+                                sh """make ${jopt} --no-print-directory -C tests timeout=600 global-timeout=14400 tests debug=no archive-errors=${BuildDir}/tests/crashes/full-nodebug"""
+                        }
+                }
 …
                                 this.Compiler = new CC_Desc('gcc-7', 'g++-7', 'gcc-7', '-flto=auto')
                         break
                         case 'gcc-6':
                                 this.Compiler = new CC_Desc('gcc-6', 'g++-6', 'gcc-6', '-flto=auto')
                         break
                         case 'gcc-5':
                                 this.Compiler = new CC_Desc('gcc-5', 'g++-5', 'gcc-5', '-flto=auto')
                         break
                         case 'gcc-4.9':
                                 this.Compiler = new CC_Desc('gcc-4.9', 'g++-4.9', 'gcc-4.9', '-flto=auto')
                         break
+                        // case 'gcc-6':
+                        //      this.Compiler = new CC_Desc('gcc-6', 'g++-6', 'gcc-6', '-flto=auto')
+                        // break
+                        // case 'gcc-5':
+                        //      this.Compiler = new CC_Desc('gcc-5', 'g++-5', 'gcc-5', '-flto=auto')
+                        // break
+                        // case 'gcc-4.9':
+                        //      this.Compiler = new CC_Desc('gcc-4.9', 'g++-4.9', 'gcc-4.9', '-flto=auto')
+                        // break
                         case 'clang':
                                 this.Compiler = new CC_Desc('clang', 'clang++-10', 'gcc-10', '-flto=thin -flto-jobs=0')
 …
 def prepare_build() {
         // prepare the properties
         properties ([                                                                                                   \
                 buildDiscarder(logRotator(                                                                              \
                         artifactDaysToKeepStr: '',                                                                      \
                         artifactNumToKeepStr: '',                                                                       \
                         daysToKeepStr: '730',                                                                           \
                         numToKeepStr: '1000'                                                                            \
                 )),                                                                                                             \
                 [$class: 'ParametersDefinitionProperty',                                                                \
                         parameterDefinitions: [                                                                         \
                                 [$class: 'ChoiceParameterDefinition',                                           \
                                         description: 'Which compiler to use',                                   \
                                         name: 'Compiler',                                                                       \
                                         choices: 'gcc-11\ngcc-10\ngcc-9\ngcc-8\ngcc-7\ngcc-6\ngcc-5\ngcc-4.9\nclang',   \
                                         defaultValue: 'gcc-8',                                                          \
                                 ],                                                                                              \
                                 [$class: 'ChoiceParameterDefinition',                                           \
                                         description: 'The target architecture',                                 \
                                         name: 'Architecture',                                                           \
                                         choices: 'x64\nx86',                                                            \
                                         defaultValue: 'x64',                                                            \
                                 ],                                                                                              \
                                 [$class: 'BooleanParameterDefinition',                                                  \
+        properties ([                                                                           \
+                buildDiscarder(logRotator(                                                      \
+                        artifactDaysToKeepStr: '',                                              \
+                        artifactNumToKeepStr: '',                                               \
+                        daysToKeepStr: '730',                                                   \
+                        numToKeepStr: '1000'                                                    \
+                )),                                                                             \
+                [$class: 'ParametersDefinitionProperty',                                        \
+                        parameterDefinitions: [                                                 \
+                                [$class: 'ChoiceParameterDefinition',                           \
+                                        description: 'Which compiler to use',                   \
+                                        name: 'Compiler',                                       \
+                                        choices: 'gcc-11\ngcc-10\ngcc-9\ngcc-8\ngcc-7\nclang',  \
+                                        defaultValue: 'gcc-9',                                  \
+                                ],                                                              \
+                                [$class: 'ChoiceParameterDefinition',                           \
+                                        description: 'The target architecture',                 \
+                                        name: 'Architecture',                                   \
+                                        choices: 'x64\nx86',                                    \
+                                        defaultValue: 'x64',                                    \
+                                ],                                                              \
+                                [$class: 'BooleanParameterDefinition',                          \
                                         description: 'If false, the test suite is only ran in debug',   \
                                         name: 'RunAllTests',                                                            \
                                         defaultValue: false,                                                            \
                                 ],                                                                                              \
                                 [$class: 'BooleanParameterDefinition',                                                  \
                                         description: 'If true, jenkins also runs benchmarks',           \
                                         name: 'RunBenchmark',                                                           \
                                         defaultValue: false,                                                            \
                                 ],                                                                                              \
                                 [$class: 'BooleanParameterDefinition',                                                  \
                                         description: 'If true, jenkins also builds documentation',              \
                                         name: 'BuildDocumentation',                                                     \
                                         defaultValue: true,                                                             \
                                 ],                                                                                              \
                                 [$class: 'BooleanParameterDefinition',                                                  \
                                         description: 'If true, jenkins also publishes results',                 \
                                         name: 'Publish',                                                                        \
                                         defaultValue: false,                                                            \
                                 ],                                                                                              \
                                 [$class: 'BooleanParameterDefinition',                                                  \
                                         description: 'If true, jenkins will not send emails',           \
                                         name: 'Silent',                                                                         \
                                         defaultValue: false,                                                            \
                                 ],                                                                                              \
+                                        name: 'RunAllTests',                                    \
+                                        defaultValue: false,                                    \
+                                ],                                                              \
+                                [$class: 'BooleanParameterDefinition',                          \
+                                        description: 'If true, jenkins also runs benchmarks',   \
+                                        name: 'RunBenchmark',                                   \
+                                        defaultValue: false,                                    \
+                                ],                                                              \
+                                [$class: 'BooleanParameterDefinition',                          \
+                                        description: 'If true, jenkins also builds documentation', \
+                                        name: 'BuildDocumentation',                             \
+                                        defaultValue: true,                                     \
+                                ],                                                              \
+                                [$class: 'BooleanParameterDefinition',                          \
+                                        description: 'If true, jenkins also publishes results', \
+                                        name: 'Publish',                                        \
+                                        defaultValue: false,                                    \
+                                ],                                                              \
+                                [$class: 'BooleanParameterDefinition',                          \
+                                        description: 'If true, jenkins will not send emails',   \
+                                        name: 'Silent',                                         \
+                                        defaultValue: false,                                    \
+                                ],                                                              \
                         ],
                 ]])
+                                        // choices: 'gcc-11\ngcc-10\ngcc-9\ngcc-8\ngcc-7\ngcc-6\ngcc-5\ngcc-4.9\nclang',
+                                        // defaultValue: 'gcc-8',
         // It's unfortunate but it looks like we need to checkout the entire repo just to get

Makefile.am

-              r34b4268
+              r24d6572
 ## 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 May 17 11:02:34 2023
+## Update Count     : 56
 ###############################################################################
 …
 DIST_SUBDIRS = driver src . libcfa tests
 @LIBCFA_TARGET_MAKEFILES@ : Makefile $(srcdir)/libcfa/configure
         @$(eval config_file = $(dir $@)config.data)
         @ls $(config_file) || (echo "Missing config.data, re-run configure script again" && false)
         @$(eval config_data = $(shell cat $(config_file)))
         @echo "Configuring libcfa ($(abs_top_srcdir)/libcfa/configure) with '$(config_data)' from $(shell pwd) / $(dir $@)"
         @cd $(dir $@) && $(abs_top_srcdir)/libcfa/configure $(config_data)
+@LIBCFA_TARGET_MAKEFILES@ : Makefile ${srcdir}/libcfa/configure
+        @${eval config_file = ${dir ${@}}config.data}
+        @ls ${config_file} || (echo "Missing config.data, re-run configure script again" && false)
+        @${eval config_data = ${shell cat ${config_file}}}
+        @echo "Configuring libcfa (${abs_top_srcdir}/libcfa/configure) with '${config_data}' from ${shell pwd} / ${dir ${@}}"
+        @cd ${dir ${@}} && ${abs_top_srcdir}/libcfa/configure ${config_data}
 noinst_DATA = @LIBCFA_TARGET_MAKEFILES@
 …
 EXTRA_DIST = LICENSE doc/man/cfa.1 libcfa/configure libcfa/Makefile.dist.am libcfa/Makefile.dist.in tools/build/distcc_hash tools/build/push2dist.sh
+debug=yes
+check:
+        $(MAKE) -C tests all-tests installed=no debug=${debug}
+debug ?= yes
+installed ?= no
+ARCH = ${if ${arch},"arch=${arch}"}
+arch_support = "x86/x64/arm"
+installcheck:
+        $(MAKE) -C tests all-tests installed=yes debug=${debug}
+# target "all" created by automake
 configure-libcfa: @LIBCFA_TARGET_MAKEFILES@
         @true
+check :
+        ${MAKE} -C tests tests installed=${installed} debug=${debug} ${ARCH}
+status: @LIBCFA_TARGET_MAKEFILES@
+tests : check # synonym
+installcheck :
+        ${MAKE} -C tests tests installed=yes debug=${debug} ${ARCH}
+installtest : installcheck # synonym
+status : @LIBCFA_TARGET_MAKEFILES@
         @echo -ne "translator\n\t"
         @./config.status --config | sed "s/ /\n\t/g; s/\t'/\t/g; s/'\n/\n/g; s/^'//g; s/'$$//g"
         @find libcfa -name config.status -printf "\n%h\n\t" -exec {} --config \; | sed "s/ /\n\t/g; s/\t'/\t/g; s/'\n/\n/g; s/^'//g; s/'$$//g"
+@LIBCFA_TARGET_DIRS@::
+        $(MAKE) -C $@ $(MAKECMDGOALS)
+help :
+        @echo "user targets:"
+        @echo "    Compile compiler/runtime."
+        @echo "    $$ make (null) / all"
+        @echo ""
+        @echo "    Compile compiler/runtime and run test suite."
+        @echo "    $$ make check / tests [debug=yes/no] [installed=yes/no] [arch=${arch_support}]"
+        @echo ""
+        @echo "    Compile compiler/runtime, install, and run test suite on installed system."
+        @echo "    $$ make installcheck / installtests [debug=yes/no] installed=yes [arch=${arch_support}]"
+        @echo ""
+        @echo "    Print configuration parameters and system build information."
+        @echo "    $$ make status"
+mostlyclean clean distclean maintainer-clean: @LIBCFA_TARGET_DIRS@
+configure-libcfa : @LIBCFA_TARGET_MAKEFILES@
+        @true
+@LIBCFA_TARGET_DIRS@ ::
+        ${MAKE} -C ${@} ${MAKECMDGOALS}
+mostlyclean clean distclean maintainer-clean : @LIBCFA_TARGET_DIRS@

benchmark/Makefile.am

-              r34b4268
+              r24d6572
 ## Created On       : Sun May 31 09:08:15 2015
 ## Last Modified By : Peter A. Buhr
 ## Last Modified On : Tue Mar 10 11:41:18 2020
 ## Update Count     : 258
+## Last Modified On : Fri May 26 12:13:48 2023
+## Update Count     : 260
 ###############################################################################
 …
 ## =========================================================================================================
 mutexStmt$(EXEEXT) :                \
         mutexStmt-cpp1.run                      \
         mutexStmt-cpp2.run                      \
         mutexStmt-cpp4.run                      \
         mutexStmt-cpp8.run                      \
         mutexStmt-java.run                      \
         mutexStmt-lock1.run                 \
         mutexStmt-lock2.run                 \
         mutexStmt-lock4.run                 \
         mutexStmt-lock8.run                 \
         mutexStmt-no-stmt-lock1.run \
         mutexStmt-no-stmt-lock2.run \
         mutexStmt-no-stmt-lock4.run \
         mutexStmt-no-stmt-lock8.run \
         mutexStmt-monitor1.run      \
         mutexStmt-monitor2.run      \
+mutexStmt$(EXEEXT) :                    \
+        mutexStmt-cpp1.run              \
+        mutexStmt-cpp2.run              \
+        mutexStmt-cpp4.run              \
+        mutexStmt-cpp8.run              \
+        mutexStmt-java.run              \
+        mutexStmt-lock1.run             \
+        mutexStmt-lock2.run             \
+        mutexStmt-lock4.run             \
+        mutexStmt-lock8.run             \
+        mutexStmt-no-stmt-lock1.run     \
+        mutexStmt-no-stmt-lock2.run     \
+        mutexStmt-no-stmt-lock4.run     \
+        mutexStmt-no-stmt-lock8.run     \
+        mutexStmt-monitor1.run          \
+        mutexStmt-monitor2.run          \
         mutexStmt-monitor4.run
 …
         compile-array.make      \
         compile-attributes.make \
         compile-empty.make      \
+        compile-empty.make      \
         compile-expression.make \
         compile-io.make         \
 …
 compile-monitor$(EXEEXT):
         $(CFACOMPILE) -DNO_COMPILED_PRAGMA -fsyntax-only -w $(testdir)/concurrent/monitor.cfa
+        $(CFACOMPILE) -DNO_COMPILED_PRAGMA -fsyntax-only -w $(testdir)/concurrency/monitor.cfa
 compile-operators$(EXEEXT):
 …
 compile-thread$(EXEEXT):
         $(CFACOMPILE) -DNO_COMPILED_PRAGMA -fsyntax-only -w $(testdir)/concurrent/thread.cfa
+        $(CFACOMPILE) -DNO_COMPILED_PRAGMA -fsyntax-only -w $(testdir)/concurrency/thread.cfa
 compile-typeof$(EXEEXT):

configure.ac

-              r34b4268
+              r24d6572
 #==============================================================================
 # HACK to be able to use conditionnals inside makefiles
+# HACK to be able to use conditionals inside makefiles
 DOifskipcompile='ifeq ($(skipcompile),yes)
 else'
 …
 AC_PROG_YACC
 if test "${YACC}" = "yacc" ; then echo "Error: bison required." ; exit 1 ; fi
 AC_PROG_LEX
+AC_PROG_LEX(yywrap)
 if test "${LEX}" = "lex" ; then echo "Error: flex required." ; exit 1 ; fi
+AC_PROG_LIBTOOL
+LT_INIT
 AC_PROG_INSTALL
 …
                 tools/Makefile
                 tools/prettyprinter/Makefile
+                benchmark/Cargo.toml
         ])
-        AC_OUTPUT(benchmark/Cargo.toml)
 ])
 AC_CONFIG_LINKS([tests/test.py:tests/test.py])
+AC_OUTPUT(tests/config.py)
+AC_CONFIG_FILES([tests/config.py])
+AC_OUTPUT
 # Final text

doc/LaTeXmacros/common.sty

-              r34b4268
+              r24d6572
 %% Created On       : Sat Apr  9 10:06:17 2016
 %% Last Modified By : Peter A. Buhr
 %% Last Modified On : Sat Apr  2 17:35:23 2022
 %% Update Count     : 570
+%% Last Modified On : Tue Apr  4 12:03:19 2023
+%% Update Count     : 585
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 …
 \setlist[itemize,1]{label=\textbullet}% local
 %\renewcommand{\labelitemi}{{\raisebox{0.25ex}{\footnotesize$\bullet$}}}
 \setlist[enumerate]{listparindent=\parindent}% global
+\setlist[enumerate]{topsep=0.5ex,parsep=0.25ex,itemsep=0.25ex,listparindent=\parindent}% global
 \setlist[enumerate,2]{leftmargin=\parindent,labelsep=*,align=parleft,label=\alph*.}% local
 \setlist[description]{topsep=0.5ex,itemsep=0pt,listparindent=\parindent,leftmargin=\parindent,labelsep=1.5ex}
 …
 \newcommand{\CCseventeen}{\protect\CCIcon{17}\xspace}   % C++17 symbolic name
 \newcommand{\CCtwenty}{\protect\CCIcon{20}\xspace}              % C++20 symbolic name
 \newcommand{\Csharp}{C\raisebox{-0.7ex}{\Large$^\sharp$}\xspace} % C# symbolic name
+\newcommand{\Csharp}{C\raisebox{-0.7ex}{\relsize{2}$^\sharp$}\xspace} % C# symbolic name
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\usepackage{pslatex}                                                                    % reduce size of san serif font
+\usepackage[scaled=0.85]{helvet}                                                % descent Helvetica font and scale to times size
+\usepackage[T1]{fontenc}
 \usepackage{relsize}                                                                    % must be after change to small or selects old size
 \usepackage{rotating}
 …
 \newcommand{\viz}{\VIZ\CheckPeriod}
+\newcommand{\VS}{\abbrevFont{vs}}
+\newcommand{\vs}{\VS\CheckPeriod}
 \newenvironment{cquote}{%
         \list{}{\lstset{resetmargins=true,aboveskip=0pt,belowskip=0pt}\topsep=4pt\parsep=0pt\leftmargin=\parindentlnth\rightmargin\leftmargin}%
 …
 \renewcommand{\reftextpagerange}[2]{\unskip, pp.~\pageref{#1}--\pageref{#2}}
 \newcommand{\VRef}[2][Section]{\ifx#1\@empty\else{#1}\nobreakspace\fi\vref{#2}}
+\newcommand{\VRefrange}[3][Sections]{\ifx#1\@empty\else{#1}\nobreakspace\fi\vrefrange{#2}{#3}}
 \newcommand{\VPageref}[2][page]{\ifx#1\@empty\else{#1}\nobreakspace\fi\pageref{#2}}
+\newcommand{\VPagerefrange}[3][pages]{\ifx#1\@empty\else{#1}\nobreakspace\fi\pageref{#2}{#3}}
 \let\Oldthebibliography\thebibliography
 …
 \newcommand{\LstCommentStyle}[1]{{\lst@basicstyle{\lst@commentstyle{#1}}}}
 \newcommand{\LstStringStyle}[1]{{\lst@basicstyle{\lst@stringstyle{#1}}}}
+\newcommand{\LstNumberStyle}[1]{{\lst@basicstyle{\lst@numberstyle{#1}}}}
 \newlength{\gcolumnposn}                                % temporary hack because lstlisting does not handle tabs correctly
 …
 columns=fullflexible,
 basicstyle=\linespread{0.9}\sf,                 % reduce line spacing and use sanserif font
 stringstyle=\tt,                                                % use typewriter font
+stringstyle=\small\tt,                                  % use typewriter font
 tabsize=5,                                                              % N space tabbing
 xleftmargin=\parindentlnth,                             % indent code to paragraph indentation

doc/LaTeXmacros/common.tex

-              r34b4268
+              r24d6572
 %% Created On       : Sat Apr  9 10:06:17 2016
 %% Last Modified By : Peter A. Buhr
 %% Last Modified On : Tue Apr 26 16:02:48 2022
 %% Update Count     : 558
+%% Last Modified On : Tue Apr  4 12:03:18 2023
+%% Update Count     : 567
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 …
 \newcommand{\CCseventeen}{\protect\CCIcon{17}\xspace}   % C++17 symbolic name
 \newcommand{\CCtwenty}{\protect\CCIcon{20}\xspace}              % C++20 symbolic name
 \newcommand{\Csharp}{C\raisebox{-0.7ex}{\Large$^\sharp$}\xspace} % C# symbolic name
+\newcommand{\Csharp}{C\raisebox{-0.7ex}{\relsize{2}$^\sharp$}\xspace} % C# symbolic name
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\usepackage{pslatex}                                                                    % reduce size of san serif font
+\usepackage[scaled=0.85]{helvet}                                                % descent Helvetica font and scale to times size
+\usepackage[T1]{fontenc}
 \usepackage{relsize}                                                                    % must be after change to small or selects old size
 \usepackage{rotating}
 …
 \newcommand{\viz}{\VIZ\CheckPeriod}
+\newcommand{\VS}{\abbrevFont{vs}}
+\newcommand{\vs}{\VS\CheckPeriod}
 \makeatother
 …
 \newcommand{\LstCommentStyle}[1]{{\lst@basicstyle{\lst@commentstyle{#1}}}}
 \newcommand{\LstStringStyle}[1]{{\lst@basicstyle{\lst@stringstyle{#1}}}}
+\newcommand{\LstNumberStyle}[1]{{\lst@basicstyle{\lst@numberstyle{#1}}}}
 \newlength{\gcolumnposn}                                % temporary hack because lstlisting does not handle tabs correctly
 …
 columns=fullflexible,
 basicstyle=\linespread{0.9}\sf,                 % reduce line spacing and use sanserif font
 stringstyle=\tt,                                                % use typewriter font
+stringstyle=\small\tt,                                  % use typewriter font
 tabsize=5,                                                              % N space tabbing
 xleftmargin=\parindentlnth,                             % indent code to paragraph indentation

doc/LaTeXmacros/lstlang.sty

-              r34b4268
+              r24d6572
 %% Created On       : Sat May 13 16:34:42 2017
 %% Last Modified By : Peter A. Buhr
 %% Last Modified On : Mon May 31 08:20:41 2021
 %% Update Count     : 28
+%% Last Modified On : Tue May  2 08:52:35 2023
+%% Update Count     : 30
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 …
 \lstdefinelanguage{CFA}[ANSI]{C}{
         morekeywords={
+                _Alignas, _Alignof, __alignof, __alignof__, asm, __asm, __asm__, __attribute, __attribute__,
+                auto, basetypeof, _Bool, catch, catchResume, choose, _Complex, __complex, __complex__, __const, __const__,
+                coroutine, disable, dtype, enable, exception, __extension__, fallthrough, fallthru, finally, fixup,
+                __float80, float80, __float128, float128, forall, ftype, generator, _Generic, _Imaginary, __imag, __imag__,
+                inline, __inline, __inline__, __int128, int128, __label__, monitor, mutex, _Noreturn, one_t, or,
+                otype, restrict, __restrict, __restrict__, recover, report, __signed, __signed__, _Static_assert, suspend,
+                thread, __thread, _Thread_local, throw, throwResume, timeout, trait, try, ttype, typeof, __typeof, __typeof__,
+                virtual, __volatile, __volatile__, waitfor, when, with, zero_t,
+                _Alignas, _Alignof, __alignof, __alignof__, and, asm, __asm, __asm__, _Atomic, __attribute, __attribute__,
+                __auto_type, basetypeof, _Bool, catch, catchResume, choose, coerce, _Complex, __complex, __complex__, __const, __const__,
+                coroutine, _Decimal32, _Decimal64, _Decimal128, disable, enable, exception, __extension__, fallthrough, fallthru, finally, fixup,
+                __float80, float80, __float128, float128, _Float16, _Float32, _Float32x, _Float64, _Float64x, _Float128, _Float128x,
+                forall, fortran, generator, _Generic, _Imaginary, __imag, __imag__, inline, __inline, __inline__, int128, __int128, __int128_t,
+                __label__, monitor, mutex, _Noreturn, __builtin_offsetof, one_t, or, recover, report, restrict, __restrict, __restrict__,
+                __signed, __signed__, _Static_assert, suspend, thread, __thread, _Thread_local, throw, throwResume, timeout, trait, try,
+                typeof, __typeof, __typeof__, typeid, __uint128_t, __builtin_va_arg, __builtin_va_list, virtual, __volatile, __volatile__,
+                vtable, waitfor, waituntil, when, with, zero_t,
     },
         moredirectives={defined,include_next}%

doc/bibliography/pl.bib

-              r34b4268
+              r24d6572
     author      = {Zhang, Yizhou and Salvaneschi, Guido and Beightol, Quinn and Liskov, Barbara and Myers, Andrew C.},
     title       = {Accepting Blame for Safe Tunneled Exceptions},
     booktitle   = {Proceedings of the 37th ACM SIGPLAN Conference on Programming Language Design and Implementation},
+    organization= {Proceedings of the 37th ACM SIGPLAN Conference on Programming Language Design and Implementation},
     series      = {PLDI'16},
     year        = {2016},
 …
+}
+@inproceedings{Koster16,
+    keywords    = {Actor Model, Concurrency},
+    contributer = {pabuhr@plg},
+    author      = {De Koster, Joeri and Van Cutsem, Tom and De Meuter, Wolfgang},
+    title       = {43 Years of Actors: A Taxonomy of Actor Models and Their Key Properties},
+    publisher   = {ACM},
+    address     = {New York, NY, USA},
+    organization= {Proceedings of the 6th International Workshop on Programming Based on Actors, Agents, and Decentralized Control},
+    pages       = {31-40},
+    numpages    = {10},
+    year        = {2016},
+    location    = {Amsterdam, Netherlands},
+    series      = {AGERE 2016}
+}
+@misc{ActorBenchmarks,
+    keywords    = {Actors, microbenchmarks, uC++. CAF, ProtoActor, AkkaC, AkkaT},
+    contributer = {pabuhr@plg},
+    key         = {ActorBenchmarks},
+    title       = {Actor Benchmarks},
+    author      = {Peter A. Buhr and Colby A. Parsons},
+    howpublished= {\href{https://github.com/pabuhr/ActorExperiments}{https://\-github.com/\-pabuhr/\-ActorExperiments}},
+    year        = 2022,
+}
 @book{Actors,
     keywords    = {actors, concurrency},
 …
     publisher   = {MIT Press, Cambridge},
     year        = 1986
+}
+@inproceedings{Srinivasan08,
+    author      = {Srinivasan, Sriram and Mycroft, Alan},
+    editor      = {Vitek, Jan},
+    title       = {Kilim: Isolation-Typed Actors for Java},
+    organization= {ECOOP 2008 -- Object-Oriented Programming},
+    year        = {2008},
+    publisher   = {Springer Berlin Heidelberg},
+    address     = {Berlin, Heidelberg},
+    pages       = {104--128},
+}
+@inproceedings{Haller07,
+    author      = {Haller, Philipp and Odersky, Martin},
+    editor      = {Murphy, Amy L. and Vitek, Jan},
+    title       = {Actors That Unify Threads and Events},
+    organization= {Coordination Models and Languages},
+    year        = 2007,
+    publisher   = {Springer Berlin Heidelberg},
+    address     = {Berlin, Heidelberg},
+    pages       = {171-190},
+}
 …
+}
+@manual{Ada95,
+    keywords    = {Ada},
+    contributer = {pabuhr@plg},
+    title       = {{A}da Reference Manual},
+    edition     = {International Standard {ISO}/{IEC} {8652:1995(E)} with {COR.1:2000}},
+    organization= {Intermetrics, Inc.},
+    month       = dec,
+    year        = 1995,
+    note        = {Language and Standards Libraries}
+}
+@manual{Ada12,
+    keywords    = {ISO/IEC Ada},
+    contributer = {pabuhr@plg},
+    author      = {Ada12},
+    title       = {Programming languages -- {Ada} ISO/IEC 8652:2012},
+    edition     = {3rd},
+    organization= {International Standard Organization},
+    address     = {Geneva, Switzerland},
+    year        = 2012,
+    note        = {\href{https://www.iso.org/standard/61507.html}{https://\-www.iso.org/\-standard/\-61507.html}},
+}
+@manual{Ada95:annotated,
+    keywords    = {Ada},
+    contributer = {pabuhr@plg},
+    title       = {Annotated {A}da Reference Manual},
+    edition     = {International Standard {ISO}/{IEC} {8652:1995(E)} with {COR.1:2000}},
+    organization= {Intermetrics, Inc.},
+    month       = dec,
+    year        = 1995,
+    note        = {Language and Standards Libraries}
+}
 @article{dim:ada,
     keywords    = {Dimensional Analysis, Ada},
 …
     number      = 2,
     pages       = {189-203},
+}
+@article{Agrawal08,
+    keywords    = {Adaptive scheduling, multiprocessing, processor allocation, randomized algorithm, space sharing, thread scheduling, two-level scheduling, work-stealing},
+    author      = {Agrawal, Kunal and Leiserson, Charles E. and He, Yuxiong and Hsu, Wen Jing},
+    title       = {Adaptive Work-stealing with Parallelism Feedback},
+    journal     = {ACM Trans. Comput. Syst.},
+    issue_date  = {September 2008},
+    volume      = {26},
+    number      = {3},
+    month       = sep,
+    year        = {2008},
+    pages       = {7:1-7:32},
+    publisher   = {ACM},
+    address     = {New York, NY, USA},
+}
 …
     month       = sep,
     year        = 2016,
+    note        = {\href{http://doc.akka.io/docs/akka/2.4/AkkaScala.pdf}{http://\-doc.akka.io/\-docs/\-akka/\-2.4/\-AkkaScala.pdf}},
+    note        = {\url{http://doc.akka.io/docs/akka/2.4/AkkaScala.pdf}},
+}
+@misc{AkkaClassic,
+    contributer = {pabuhr@plg},
+    key         = {AkkaClassic},
+    title       = {Akka Classic Actors},
+    author      = {{Lightbend}},
+    howpublished= {\url{https://doc.akka.io/docs/akka/current/index-classic.html}},
+    year        = 2023,
+}
+@misc{AkkaFuture,
+    contributer = {pabuhr@plg},
+    key         = {AkkaFuture},
+    title       = {Akka Futures},
+    author      = {{Lightbend}},
+    howpublished= {\url{https://doc.akka.io/docs/akka/2.5/futures.html}},
+    year        = 2022,
+}
+@misc{AkkaTyped,
+    contributer = {pabuhr@plg},
+    key         = {AkkaTyped},
+    title       = {Akka Typed Actors},
+    author      = {{Lightbend}},
+    howpublished= {\url{https://doc.akka.io/docs/akka/2.5/typed-actors.html}},
+    year        = 2022,
+}
 …
+}
+@inproceedings{Mitzenmacher98,
+    author      = {Mitzenmacher, Michael},
+    title       = {Analyses of Load Stealing Models Based on Differential Equations},
+    organization= {Proceedings of the Tenth Annual ACM Symposium on Parallel Algorithms and Architectures},
+    series      = {SPAA '98},
+    year        = {1998},
+    isbn        = {0-89791-989-0},
+    location    = {Puerto Vallarta, Mexico},
+    pages       = {212-221},
+    publisher   = {ACM},
+    address     = {New York, NY, USA},
+}
+@inproceedings{Squillante91,
+    author      = {Squillante, Mark S. and Nelson, Randolph D.},
+    title       = {Analysis of Task Migration in Shared-memory Multiprocessor Scheduling},
+    organization= {Proceedings of the 1991 ACM SIGMETRICS Conference on Measurement and Modeling of Computer Systems},
+    series      = {SIGMETRICS '91},
+    year        = {1991},
+    isbn        = {0-89791-392-2},
+    location    = {San Diego, California, USA},
+    pages       = {143-155},
+    publisher   = {ACM},
+    address     = {New York, NY, USA},
+}
 @article{Sinha00,
     author      = {Saurabh Sinha and Mary Jean Harrold},
 …
     author      = {Martin P. Robillard and Gail C. Murphy},
     title       = {Analyzing Exception Flow in {J}ava Programs},
     booktitle   = {ESEC/FSE-7: Proceedings of the 7th European Software Engineering Conference held jointly
+    organization= {ESEC/FSE-7: Proceedings of the 7th European Software Engineering Conference held jointly
                    with the 7th ACM SIGSOFT International Symposium on Foundations of Software Engineering},
     year        = 1999,
 …
     author      = {Henry Qin and Qian Li and Jacqueline Speiser and Peter Kraft and John Ousterhout},
     title       = {Arachne: Core-Aware Thread Management},
     booktitle   = {13th {USENIX} Symp. on Oper. Sys. Design and Impl. ({OSDI} 18)},
+    organization= {13th {USENIX} Symp. on Oper. Sys. Design and Impl. ({OSDI} 18)},
     year        = {2018},
     address     = {Carlsbad, CA},
 …
     author      = {Jaewoong Chung and Luke Yen and Stephan Diestelhorst and Martin Pohlack and Michael Hohmuth and David Christie and Dan Grossman},
     title       = {ASF: AMD64 Extension for Lock-Free Data Structures and Transactional Memory},
     booktitle   = {Proceedings of the 2010 43rd Annual IEEE/ACM International Symposium on Microarchitecture},
+    organization= {Proceedings of the 2010 43rd Annual IEEE/ACM International Symposium on Microarchitecture},
     series      = {MICRO '43},
     year        = 2010,
 …
+}
+@misc{AsyncAwait,
+    contributer = {pabuhr@plg},
+    key         = {AsyncAwait},
+    title       = {Async Await},
+    author      = {{WikipediA}},
+    howpublished= {\href{https://en.wikipedia.org/wiki/Async/await}{https://\-en.wikipedia.org/\-wiki/\-Async/\-await}},
+    year        = 2022,
+}
 @inproceedings{Krischer08,
     keywords    = {exception handling, asynchronous, blocked tasks},
 …
     author      = {Roy Krischer and Peter A. Buhr},
     title       = {Asynchronous Exception Propagation in Blocked Tasks},
     booktitle   = {4th International Workshop on Exception Handling (WEH.08)},
+    organization= {4th International Workshop on Exception Handling (WEH.08)},
     optorganization= {16th International Symposium on the Foundations of Software Engineering (FSE 16)},
     address     = {Atlanta, U.S.A},
 …
 @article{Joung00,
+    keywords    = {group mutual exclusion, congenial talking philosophers, resource allocation, shared-memory algorithms},
     author      = {Joung, Yuh-Jzer},
     title       = {Asynchronous group mutual exclusion},
 …
     publisher   = {ACM},
     address     = {New York, NY, USA},
+}
+@techreport{Neill09,
+    author      = {Daniel Neill and Adam Wierman},
+    title       = {On the Benefits of Work Stealing in Shared-Memory Multiprocessors},
+    institution = {Carnegie Mellon University},
+    address     = {California Institute of Technology, Pasadena, CA, USA},
+    note        = {\href{http://www.cs.cmu.edu/~acw/15740/paper.pdf}{http://\-www.cs.cmu.edu/\-$\sim$acw/\-15740/\-paper.pdf}, Accessed May 2014},
+    year        = 2009,
+}
 …
+}
+@inproceedings{Ding12,
+    keywords    = {fairness, multicore, time sharing, work stealing},
+    author      = {Ding, Xiaoning and Wang, Kaibo and Gibbons, Phillip B. and Zhang, Xiaodong},
+    title       = {BWS: Balanced Work Stealing for Time-sharing Multicores},
+    organization= {Proceedings of the 7th ACM European Conference on Computer Systems},
+    series      = {EuroSys '12},
+    year        = {2012},
+    location    = {Bern, Switzerland},
+    pages       = {365-378},
+    publisher   = {ACM},
+    address     = {New York, NY, USA},
+}
 % C
 …
+}
+@inproceedings{CAF,
+    keywords    = {performance measurement, actor model, c++, message-oriented middleware, distributed debugging},
+    contributer = {pabuhr@plg},
+    author      = {Charousset, Dominik and Hiesgen, Raphael and Schmidt, Thomas C.},
+    title       = {{CAF} -- the {C}++ Actor Framework for Scalable and Resource-Efficient Applications},
+    publisher   = {ACM},
+    address     = {New York, NY, USA},
+    organization= {Proceedings of the 4th International Workshop on Programming Based on Actors Agents \& Decentralized Control},
+    pages       = {15-28},
+    numpages    = 14,
+    location    = {Portland, Oregon, USA},
+    series      = {AGERE'14},
+    year        = 2014,
+}
 @techreport{cfa-cc,
     keywords    = {Cforall, cfa-cc, transpiler},
 …
     year        = 2018,
     pages       = {2111-2146},
     note        = {\href{http://dx.doi.org/10.1002/spe.2624}{http://\-dx.doi.org/\-10.1002/\-spe.2624}},
+    optnote     = {\href{http://dx.doi.org/10.1002/spe.2624}{http://\-dx.doi.org/\-10.1002/\-spe.2624}},
+}
 …
 @techreport{Prokopec11,
     keywords    = {ctrie, concurrent map},
     contributer = {a3moss@uwaterloo.ca},
+    contributer = {a3moss@uwaterloo.ca},
     title       = {Cache-aware lock-free concurrent hash tries},
     author      = {Prokopec, Aleksandar and Bagwell, Phil and Odersky, Martin},
 …
     author      = {Emery D. Berger and Benjamin G. Zorn and Kathryn S. McKinley},
     title       = {Composing High-Performance Memory Allocators},
     booktitle   = {{SIGPLAN} Conference on Programming Language Design and Implementation},
+    organization= {{SIGPLAN} Conference on Programming Language Design and Implementation},
     pages       = {114-124},
     year        = 2001,
 …
     month       = sep,
     year        = 2020,
     note        = {\href{https://plg.uwaterloo.ca/~usystem/pub/uSystem/uC++.pdf}{https://\-plg.uwaterloo.ca/\-$\sim$usystem/\-pub/\-uSystem/uC++.pdf}},
+    note        = {\url{https://plg.uwaterloo.ca/~usystem/pub/uSystem/uC++.pdf}},
+}
 …
     number      = 5,
     pages       = {1005-1042},
     note        = {\href{https://onlinelibrary.wiley.com/doi/10.1002/spe.2925}{https://\-onlinelibrary.wiley.com/\-doi/\-10.1002/\-spe.2925}},
+    optnote     = {\href{https://onlinelibrary.wiley.com/doi/10.1002/spe.2925}{https://\-onlinelibrary.wiley.com/\-doi/\-10.1002/\-spe.2925}},
+}
 …
     address     = {Eindhoven, Neth.},
     year        = 1965,
+    note        = {Reprinted in \cite{Genuys68} pp. 43--112.}
+    optnote     = {Reprinted in \cite{Genuys68} pp. 43--112.},
+    note        = {\url{https://pure.tue.nl/ws/files/4279816/344354178746665.pdf}},
+}
 …
     author      = {Adya, Atul and Howell, Jon and Theimer, Marvin and Bolosky, William J. and Douceur, John R.},
     title       = {Cooperative Task Management Without Manual Stack Management},
     booktitle   = {Proc. of the General Track USENIX Tech. Conf.},
+    organization= {Proc. of the General Track USENIX Tech. Conf.},
     series      = {ATEC '02},
     year        = {2002},
 …
     year        = 2016,
     note        = {\href{http://dlang.org/spec/spec.html}{http://\-dlang.org/\-spec/\-spec.html}},
+}
+@article{Acar02,
+    author      = {Acar, Umut A. and Blelloch, Guy E. and Blumofe, Robert D.},
+    title       = {The Data Locality of Work Stealing},
+    journal     = {Theory of Computing Systems},
+    volume      = {35},
+    number      = {3},
+    year        = {2002},
+    publisher   = {Springer-Verlag},
+    pages       = {321-347},
+}
 …
     editor      = {R. E. A. Mason},
     organization= {IFIP},
     publisher = {North-Holland},
     summary = {
+    publisher   = {North-Holland},
+    summary     = {
         Packages group related declarations or subprograms, and encapsulate
         data types.  Separate interfaces and bodies promotes information
 …
     address     = {Waterview Corporate Center, 20 Waterview Boulevard, Parsippany, NJ 07054},
     year        = {1993}
+}
+@inproceedings{Chen14,
+    keywords    = {Core allocation, Multi-programmed, Work-stealing},
+    author      = {Chen, Quan and Zheng, Long and Guo, Minyi},
+    title       = {DWS: Demand-aware Work-Stealing in Multi-programmed Multi-core Architectures},
+    organization= {Proceedings of Programming Models and Applications on Multicores and Manycores},
+    series      = {PMAM'14},
+    year        = {2007},
+    location    = {Orlando, FL, USA},
+    pages       = {131:131-131:139},
+    articleno   = {131},
+    numpages    = {9},
+    publisher   = {ACM},
+    address     = {New York, NY, USA},
+}
 …
     year        = 2003,
     pages       = {29-35},
+}
+@inproceedings{Hamidzadeh96,
+    keywords    = {processor scheduling, resource allocation, shared memory systems, average memory referencing delay},
+    author      = {Hamidzadeh, B. and Lilja, D.J.},
+    booktitle   = {Distributed Computing Systems, 1996., Proceedings of the 16th International Conference on},
+    title       = {Dynamic scheduling strategies for shared-memory multiprocessors},
+    year        = {1996},
+    month       = {May},
+    pages       = {208-215},
+}
+@article{Hendler06,
+    keywords    = {Concurrent programming; Load balancing; Work stealing; Lock-free; Data structures},
+    author      = {Hendler, Danny and Lev, Yossi and Moir, Mark and Shavit, Nir},
+    title       = {A dynamic-sized nonblocking work stealing deque},
+    journal     = {Distributed Computing},
+    volume      = {18},
+    number      = {3},
+    year        = {2006},
+    publisher   = {Springer-Verlag},
+    pages       = {189-207},
+}
 …
+}
+@inproceedings{Blelloch04,
+    keywords    = {chip multiprocessors, multithreaded architectures, scheduling algorithms, shared cache},
+    author      = {Blelloch, Guy E. and Gibbons, Phillip B.},
+    title       = {Effectively Sharing a Cache Among Threads},
+    organization= {Proceedings of the Sixteenth Annual ACM Symposium on Parallelism in Algorithms and Architectures},
+    series      = {SPAA '04},
+    year        = {2004},
+    location    = {Barcelona, Spain},
+    pages       = {235-244},
+    publisher   = {ACM},
+    address     = {New York, NY, USA},
+}
 @techreport{Habermann80,
     keywords    = {Ada, threads},
 …
     title       = {Encapsulation and Inheritance in Object-Oriented Programming Languages},
     journal     = sigplan,
+    volume      = {21},    number = {11},
+    volume      = {21},
+    number      = {11},
     pages       = {38-45},
+    month       = nov, year = 1986,
+    month       = nov,
+    year        = 1986,
     comment     = {
         Client, child interfaces should be distinct.  Child interface
 …
+}
+@inproceedings{Ribic14,
+    keywords    = {dvfs, energy efficiency, language runtimes, thread management, work stealing},
+    author      = {Ribic, Haris and Liu, Yu David},
+    title       = {Energy-efficient Work-stealing Language Runtimes},
+    organization= {Proceedings of the 19th International Conference on Architectural Support for Programming Languages and Operating Systems},
+    series      = {ASPLOS '14},
+    year        = {2014},
+    location    = {Salt Lake City, Utah, USA},
+    pages       = {513-528},
+    publisher   = {ACM},
+    address     = {New York, NY, USA},
+}
 @manual{EPT,
     keywords    = {concurrency, light-weight threads},
 …
+}
+@misc{Soleimani16,
+    keywords    = {Erlang, scheduler, history},
+    contributer = {pabuhr@plg},
+    author      = {Hamidreza Soleimani},
+    title       = {Erlang Scheduler Details and Why It Matters},
+    month       = feb,
+    year        = 2016,
+    howpublished= {\url{https://hamidreza-s.github.io/erlang/scheduling/real-time/preemptive/migration/2016/02/09/erlang-scheduler-details.html}},
+}
 @inproceedings{MH88,
     keywords    = {modules, general sums, general products},
 …
     publisher   = {North Oxford Academic},
     year        = 1985
+}
+@article{Torrellas95,
+    author      = {J. Torrellas and A. Tucker and A. Gupta},
+    title       = {Evaluating the Performance of Cache-Affinity Scheduling in Shared-Memory Multiprocessors},
+    journal     = {Journal of Parallel and Distributed Computing},
+    volume      = {24},
+    number      = {2},
+    pages       = {139-151},
+    year        = {1995},
+}
 …
     author      = {Robert Griesemer and Rob Pike and Ken Thompson},
     title       = {{Go} Programming Language},
+    address     = {Mountain View, CA, USA},
     organization= {Google},
     year        = 2009,
 …
 @article{Michael04a,
     keywords    = {Lock-free, synchronization, concurrent programming, memory management, multiprogramming, dynamic data structures},
+    contributer = {pabuhr@plg},
     author      = {Maged M. Michael},
     title       = {Hazard Pointers: Safe Memory Reclamation for Lock-Free Objects},
 …
     publisher   = {IEEE Press},
     address     = {Piscataway, NJ, USA},
+}
+@inproceedings{Johansson02,
+    keywords    = {concurrent languages, erlang, garbage collection, message passing, runtime systems},
+    contributer = {pabuhr@plg},
+    author      = {Erik Johansson and Konstantinos Sagonas and Jesper Wilhelmsson},
+    title       = {Heap Architectures for Concurrent Languages Using Message Passing},
+    year        = {2002},
+    isbn        = {1581135394},
+    publisher   = {ACM},
+    address     = {New York, NY, USA},
+    organization= {Proceedings of the 3rd International Symposium on Memory Management},
+    pages       = {88-99},
+    location    = {Berlin, Germany},
+}
 …
     title       = {Implementing Lock-Free Queues},
     booktitle   = {Seventh International Conference on Parallel and Distributed Computing Systems},
+    organization= {International Society for Computers and Their Applications},
     address     = {Las Vegas, Nevada, U.S.A.},
     year        = {1994},
     pages       = {64-69},
+}
+@inproceedings{Halstead84,
+    author      = {Halstead,Jr., Robert H.},
+    title       = {Implementation of Multilisp: Lisp on a Multiprocessor},
+    organization= {Proceedings of the 1984 ACM Symposium on LISP and Functional Programming},
+    series      = {LFP '84},
+    year        = {1984},
+    location    = {Austin, Texas, USA},
+    pages       = {9-17},
+    publisher   = {ACM},
+    address     = {New York, NY, USA},
+}
 …
     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,
+    title       = {Lua 5.4 Reference Manual},
+    organization= {Pontifical Catholic University},
+    address     = {\href{https://www.lua.org/manual/5.4}{https://\-www.lua.org/\-manual/\-5.4}},
+    year        = 2020,
+}
 …
+}
 @manual{MMTk,
+@misc{MMTk,
     keywords    = {Java memory management},
     contributer = {pabuhr@plg},
 …
     month       = sep,
     year        = 2006,
+    note        = {\href{http://cs.anu.edu.au/~Robin.Garner/mmtk-guide.pdf}
+                  {http://cs.anu.edu.au/\-$\sim$Robin.Garner/\-mmtk-guide.pdf}},
+    howpublished= {\url{http://cs.anu.edu.au/~Robin.Garner/mmtk-guide.pdf}},
+}
 …
     year        = 2015,
     note        = {\href{http://www.mpi-forum.org/docs/mpi-3.1/mpi31-report.pdf}{http://www.mpi-forum.org/\-docs/\-mpi-3.1/\-mpi31-report.pdf}},
+}
+@article{Lombardo19,
+    contributer = {pabuhr@plg},
+    author      = {Lombardo, Gianfranco and Fornacciari, Paolo and Mordonini, Monica and Tomaiuolo, Michele and Poggi, Agostino},
+    title       = {A Multi-Agent Architecture for Data Analysis},
+    journal     = {Future Internet},
+    volume      = 11,
+    year        = 2019,
+    number      = 2,
+}
 …
         Programming Language},
     year        = 1980,
+    month       = dec, pages = {139-145},
+    month       = dec,
+    pages       = {139-145},
     note        = {SIGPLAN Notices, v. 15, n. 11},
     abstract    = {
 …
     year        = 2005,
     pages       = {146-196},
+    publisher   = {ACM},
+    address     = {New York, NY, USA},
+}
+@inproceedings{Hendler02,
+    author      = {Hendler, Danny and Shavit, Nir},
+    title       = {Non-blocking Steal-half Work Queues},
+    organization= {Proceedings of the Twenty-first Annual Symposium on Principles of Distributed Computing},
+    series      = {PODC '02},
+    year        = {2002},
+    location    = {Monterey, California},
+    pages       = {280-289},
     publisher   = {ACM},
     address     = {New York, NY, USA},
 …
+}
+@misc{OpenTelemetry,
+    contributer = {pabuhr@plg},
+    key         = {OpenTelemetry},
+    title       = {OpenTelemetry},
+    author      = {{Asynkron AB}},
+    howpublished= {\href{https://proto.actor/docs/tracing}{https://\-proto.actor/\-docs/\-tracing}},
+    year        = 2022,
+}
 @inproceedings{Krebbers14,
     keywords    = {c formalization},
 …
+}
+@article{Nigro21,
+    keywords    = {Actors, Asynchronous messages, Reflective control on message passing, Lock-free parallel computing, Java, Scalable multi-agent systems, Parallel matrix multiplication, Iterated Prisoner's Dilemma},
+    contributer = {pabuhr@plg},
+    author      = {Libero Nigro},
+    title       = {Parallel Theatre: An actor framework in {Java} for high performance computing},
+    journal     = {Simulation Modelling Practice and Theory},
+    volume      = {106},
+    number      = {102189},
+    year        = {2021},
+}
 @incollection{Stroustrup96,
     keywords    = {concurrency, C++},
 …
     journal     = ieeese,
     year        = 1984,
+    month       = sep, volume = "SE-10", number = 5, pages = {528-543},
+    month       = sep,
+    volume      = "SE-10",
+    number      = 5,
+    pages       = {528-543},
     abstract    = {
         Parameterized programming is a powerful technique for the reliable
 …
     booktitle   = {USENIX {C}{\kern-.1em\hbox{\large\texttt{+\kern-.25em+}}} Conference},
     organization= {USENIX Association},
+    year        = 1988, pages = {1-18}
+    year        = 1988,
+    pages       = {1-18},
+}
 …
+}
+@incollection{Kazempour08,
+    keywords    = {multicore processors; cache affinity; performance evaluation; scheduling},
+    author      = {Kazempour, Vahid and Fedorova, Alexandra and Alagheband, Pouya},
+    title       = {Performance Implications of Cache Affinity on Multicore Processors},
+    organization= {Euro-Par 2008 -- Parallel Processing},
+    series      = {Lecture Notes in Computer Science},
+    editor      = {Luque, Emilio and Margalef, Tomas and Benitez, Domingo},
+    year        = {2008},
+    volume      = {5168},
+    pages       = {151-161},
+    publisher   = {Springer Berlin Heidelberg},
+}
+@article{Anderson89,
+    keywords    = {data structures, multiprocessing systems, operating systems (computers), performance evaluation, critical resource waiting},
+    author      = {Anderson, T.E. and Lazowska, E.D. and Levy, H.M.},
+    journal     = {Computers, IEEE Transactions on},
+    title       = {The Performance Implications of Thread Management Alternatives for Shared-Memory Multiprocessors},
+    year        = {1989},
+    month       = {Dec},
+    volume      = {38},
+    number      = {12},
+    pages       = {1631-1644},
+}
 @article{Anderson90,
     keywords    = {spin locks, back off, performance},
 …
     number      = 1,
     pages       = {6-16},
+}
+@article{Blumofe98,
+    author      = {Blumofe, Robert D. and Papadopoulos, Dionisios},
+    title       = {The Performance of Work Stealing in Multiprogrammed Environments (Extended Abstract)},
+    journal     = {SIGMETRICS Perform. Eval. Rev.},
+    volume      = {26},
+    number      = {1},
+    month       = jun,
+    year        = {1998},
+    issn        = {0163-5999},
+    pages       = {266-267},
+    publisher   = {ACM},
+    address     = {New York, NY, USA},
+}
 …
+}
+@article{Varela01,
+    keywords    = {programming languages, SALSA, continuations, actors, java, internet, network computing, open systems, mobile computing},
+    contributer = {pabuhr@plg},
+    author      = {Varela, Carlos and Agha, Gul},
+    title       = {Programming Dynamically Reconfigurable Open Systems with SALSA},
+    issue_date  = {December 2001},
+    publisher   = {Association for Computing Machinery},
+    address     = {New York, NY, USA},
+    volume      = 36,
+    number      = 12,
+    journal     = {SIGPLAN Not.},
+    year        = 2001,
+    month       = dec,
+    pages       = {20-34},
+}
 @book{PowerPC,
     key         = {PowerPC processor},
 …
     title       = {Programming Languages -- {C}},
     organization= {International Standard ISO/IEC 9899:1999 (E)},
     publisher   = {American National Standards Institute},
+    publisher   = {American National Standards Institute},
     address     = {www.ansi.org},
     year        = 1999,
 …
     title       = {{C}{\kern-.1em\hbox{\large\texttt{+\kern-.25em+}}} Programming Language ISO/IEC 14882:1998},
     edition     = {1st},
     organization  = {International Standard Organization},
+    organization= {International Standard Organization},
     address     = {Geneva, Switzerland},
     year        = 1998,
 …
+}
+@misc{protoactor,
+    contributer = {pabuhr@plg},
+    key         = {Protoactor},
+    author      = {{proto.actor}},
+    title       = {Asynkron AB},
+    year        = 2023,
+    howpublished= {\url{https://proto.actor}},
+}
 @misc{Pthreads,
     keywords    = {pthreads, C concurrency},
 …
+}
+@manual{Ada95,
+    keywords    = {Ada},
+    contributer = {pabuhr@plg},
+    title       = {{A}da Reference Manual},
+    edition     = {International Standard {ISO}/{IEC} {8652:1995(E)} with {COR.1:2000}},
+    organization= {Intermetrics, Inc.},
+    month       = dec,
+    year        = 1995,
+    note        = {Language and Standards Libraries}
+}
+@manual{Ada12,
+    keywords    = {ISO/IEC Ada},
+    contributer = {pabuhr@plg},
+    author      = {Ada12},
+    title       = {Programming languages -- {Ada} ISO/IEC 8652:2012},
+    edition     = {3rd},
+    organization= {International Standard Organization},
+    address     = {Geneva, Switzerland},
+    year        = 2012,
+    note        = {\href{https://www.iso.org/standard/61507.html}{https://\-www.iso.org/\-standard/\-61507.html}},
+}
+@manual{Ada95:annotated,
+    keywords    = {Ada},
+    contributer = {pabuhr@plg},
+    title       = {Annotated {A}da Reference Manual},
+    edition     = {International Standard {ISO}/{IEC} {8652:1995(E)} with {COR.1:2000}},
+    organization = {Intermetrics, Inc.},
+    month       = dec,
+    year        = 1995,
+    note        = {Language and Standards Libraries}
+@inproceedings{Bacon03,
+    keywords    = {utilization, real-time scheduling, read barrier, defragmentation},
+    contributer = {pabuhr@plg},
+    author      = {David F. Bacon and Perry Cheng and V. T. Rajan},
+    title       = {A Real-Time Garbage Collector with Low Overhead and Consistent Utilization},
+    year        = {2003},
+    organization= {Proceedings of the 30th ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages},
+    publisher   = {ACM},
+    address     = {New York, NY, USA},
+    pages       = {285-298},
+    location    = {New Orleans, Louisiana, USA},
+}
 …
     journal     = sigplan,
     year        = 1991,
+    month       = oct, volume = 26, number = 10, pages = {29-43},
+    month       = oct,
+    volume      = 26,
+    number      = 10,
+    pages       = {29-43},
     abstract    = {
         {\tt lcc} is a new retargetable compiler for ANSI C.  Versions for
 …
+}
+@misc{rpmalloc,
+    author      = {Mattias Jansson},
+    title       = {rpmalloc version 1.4.1},
+    month       = apr,
+    year        = 2022,
+    howpublished= {\href{https://github.com/mjansson/rpmalloc}{https://\-github.com/\-mjansson/\-rpmalloc}},
+}
 @manual{Rust,
     keywords    = {Rust programming language},
 …
     publisher   = {ACM},
     address     = {New York, NY, USA},
     booktitle   = {Proceedings of the 4th International Workshop on Programming Based on Actors Agents \& Decentralized Control},
+    organization= {Proceedings of the 4th International Workshop on Programming Based on Actors Agents \& Decentralized Control},
     pages       = {67-80},
     numpages    = {14},
 …
     booktitle   = {PLDI '04: Proceedings of the ACM SIGPLAN 2004 Conference on Programming Language Design and Implementation},
     location    = {Washington DC, USA},
     publisher   = {ACM},
+    organization= {ACM},
     address     = {New York, NY, USA},
     volume      = 39,
 …
     month       = jun,
     pages       = {35-46},
+}
+@article{Nickolls08,
+    author      = {Nickolls, John and Buck, Ian and Garland, Michael and Skadron, Kevin},
+    title       = {Scalable Parallel Programming with CUDA},
+    journal     = {Queue},
+    volume      = {6},
+    number      = {2},
+    month       = mar,
+    year        = 2008,
+    pages       = {40-53},
+    publisher   = {ACM},
+    address     = {New York, NY, USA},
+}
 …
+}
+@article{Blumofe99,
+    keywords    = {critical-path length, multiprocessor, multithreading, randomized algorithm, thread scheduling, work stealing},
+    author      = {Blumofe, Robert D. and Leiserson, Charles E.},
+    title       = {Scheduling Multithreaded Computations by Work Stealing},
+    journal     = {Journal of the ACM},
+    volume      = {46},
+    number      = {5},
+    month       = sep,
+    year        = {1999},
+    pages       = {720-748},
+    publisher   = {ACM},
+    address     = {New York, NY, USA},
+}
+@inproceedings{Acar13,
+    keywords    = {dynamic load balancing, nested parallelism, work stealing},
+    author      = {Acar, Umut A. and Chargueraud, Arthur and Rainey, Mike},
+    title       = {Scheduling Parallel Programs by Work Stealing with Private Deques},
+    organization= {Proceedings of the 18th ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming},
+    series      = {PPoPP '13},
+    year        = {2013},
+    location    = {Shenzhen, China},
+    pages       = {219-228},
+    publisher   = {ACM},
+    address     = {New York, NY, USA},
+}
+@inproceedings{Chen07,
+    keywords    = {chip multiprocessors, constructive cache sharing, parallel depth first, scheduling algorithms, thread granularity, work stealing, working set profiling},
+    author      = {Chen, Shimin and Gibbons, Phillip B. and Kozuch, Michael and Liaskovitis, Vasileios and Ailamaki, Anastassia and Blelloch, Guy E. and Falsafi, Babak and Fix, Limor and Hardavellas, Nikos and Mowry, Todd C. and Wilkerson, Chris},
+    title       = {Scheduling Threads for Constructive Cache Sharing on CMPs},
+    organization= {Proceedings of the Nineteenth Annual ACM Symposium on Parallel Algorithms and Architectures},
+    series      = {SPAA '07},
+    year        = {2007},
+    location    = {San Diego, California, USA},
+    pages       = {105-115},
+    numpages    = {11},
+    publisher   = {ACM},
+    address     = {New York, NY, USA},
+}
 @manual{SELF,
     keywords    = {programming language, obect-oriented, polymorphism},
 …
     publisher   = {Springer},
     note        = {Lecture Notes in Computer Science v. 173},
+}
+@inproceedings{Kahn74,
+    keywords    = {programming language, obect-oriented, polymorphism},
+    contributer = {pabuhr@plg},
+    title       = {The Semantics of a Simple Language for Parallel Programming},
+    author      = {Gilles Kahn},
+    organization= {IFIP Congress},
+    year        = 1974,
+}
 …
     number      = 12,
     pages       = {66-76},
+}
+@book{Scott13,
+    author      = {Michael L. Scott},
+    title       = {Shared-Memory Synchronization},
+    publisher   = {Morgan \& Claypool},
+    year        = 2013,
+}
+@inproceedings{Leissa14,
+    title       = {{S}ierra: a {SIMD} extension for {C}++},
+    author      = {Lei{\ss}a, Roland and Haffner, Immanuel and Hack, Sebastian},
+    booktitle   = {Proceedings of the 2014 Workshop on Workshop on programming models for SIMD/Vector processing},
+    pages       = {17-24},
+    year        = {2014},
+    organization= {ACM}
+}
 …
 @article{SysVABI,
     keywords    =  {System V ABI},
     contributer =  {a3moss@uwaterloo.ca},
+    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},
 …
     volume      = {99},
     year        = {2013}
+}
+@article{Albert18,
+    keywords    = {actor-based concurrency, partial order reduction, systematic testing, synchronization, task independence},
+    contributer = {pabuhr@plg},
+    author      = {Albert, Elvira and Arenas, Puri and G\'{o}mez-Zamalloa, Miguel},
+    title       = {Systematic testing of actor systems},
+    journal     = {Software Testing, Verification and Reliability},
+    volume      = {28},
+    number      = {3},
+    pages       = {e1661},
+    year        = {2018}
+}
 …
     journal     = jcss,
     year        = 1978,
+    volume      = 17, pages = {348-375}
+    volume      = 17,
+    pages       = {348-375},
+}
 …
     address     = {New York, New York, U.S.A.},
     year        = 1982
+}
+@article{Arora01,
+    author      = {Arora, N. S. and Blumofe, R. D. and Plaxton, C. G.},
+    title       = {Thread Scheduling for Multiprogrammed Multiprocessors},
+    journal     = {Theory of Computing Systems},
+    year        = {2001},
+    volume      = {34},
+    number      = {2},
+    pages       = {115-144},
+    publisher   = {Springer-Verlag},
+}
 …
+}
+@misc{AkkaBecome,
+    contributer = {pabuhr@plg},
+    key         = {AkkaBecome},
+    title       = {Typed Actors},
+    author      = {{Lightbend}},
+    howpublished= {\href{https://doc.akka.io/docs/akka/2.5/typed-actors.html}{https://\-doc.akka.io/\-docs/\-akka/\-2.5/\-typed-actors.html}},
+    year        = 2022,
+}
 @article{concatenation,
     keywords    = {record concatenation, isa},
 …
     author      = {Paul R. Wilson},
     title       = {Uniprocessor Garbage Collection Techniques},
     booktitle   = {Proceedings of the International Workshop on Memory Management},
+    organization= {Proceedings of the International Workshop on Memory Management},
     location    = {St. Malo, France},
     publisher   = {Springer},
 …
     author      = {Carl Hewitt and Peter Bishop and Richard Steiger},
     title       = {A Universal Modular {ACTOR} Formalism for Artificial Intelligence},
     booktitle   = {Proceedings of the 3rd International Joint Conference on Artificial Intelligence},
+    organization= {Proceedings of the 3rd International Joint Conference on Artificial Intelligence},
     address     = {Standford, California, U.S.A.},
     pages       = {235-245},
+    location    = {Stanford, USA},
+    series      = {IJCAI'73},
     month       = aug,
     year        = 1973,
 …
 @article{Karsten20,
     author      = {Karsten, Martin and Barghi, Saman},
     title       = {{User-level Threading: Have Your Cake and Eat It Too}},
+    title       = {User-level Threading: Have Your Cake and Eat It Too},
     year        = {2020},
     issue_date  = {March 2020},
 …
+}
+@article{Squillante93,
+    keywords    = {buffer storage, performance evaluation, queueing theory, scheduling, shared memory systems, processor-cache affinity},
+    author      = {Squillante, M.S. and Lazowska, E.D.},
+    title       = {Using Processor-Cache Affinity Information in Shared-Memory Multiprocessor Scheduling},
+    journal     = {Parallel and Distributed Systems, IEEE Transactions on},
+    year        = {1993},
+    month       = {Feb},
+    volume      = {4},
+    number      = {2},
+    pages       = {131-143},
+}
 @article{delegation,
     keywords    = {delegation, inheritance, actors},
 …
     year        = 2003,
     pages       = {19-24},
+}
+@inproceedings{Saman18,
+    keywords    = {actors, scheduling, NUMA, locality},
+    contributer = {pabuhr@plg},
+    author      = {Saman Barghi and Martin Karsten},
+    organization= {2018 IEEE International Parallel and Distributed Processing Symposium (IPDPS)},
+    title       = {Work-Stealing, Locality-Aware Actor Scheduling},
+    year        = {2018},
+    address     = {Vancouver, BC, Canada},
+    pages       = {484-494},
+}
+@article{Wimmer13,
+    keywords    = {priorities, scheduler hints, strategies, work-stealing},
+    author      = {Wimmer, Martin and Cederman, Daniel and Tr\"{a}ff, Jesper Larsson and Tsigas, Philippas},
+    title       = {Work-stealing with Configurable Scheduling Strategies},
+    journal     = {SIGPLAN Not.},
+    issue_date  = {August 2013},
+    volume      = {48},
+    number      = {8},
+    month       = feb,
+    year        = {2013},
+    issn        = {0362-1340},
+    pages       = {315-316},
+    publisher   = {ACM},
+    address     = {New York, NY, USA},
+}

doc/theses/mike_brooks_MMath/Makefile

-              r34b4268
+              r24d6572
 PicSRC = ${notdir ${wildcard ${Pictures}/*.png}}
 DemoSRC = ${notdir ${wildcard ${Programs}/*-demo.cfa}}
+PgmSRC = ${notdir ${wildcard ${Programs}/*.cfa}}
+PgmSRC = ${notdir ${wildcard ${Programs}/*}}
+RunPgmSRC = ${notdir ${wildcard ${Programs}/*.run.*}}
 BibSRC = ${wildcard *.bib}
 …
 BibLIB = .:../../bibliography                   # common citation repository
 MAKEFLAGS = --no-print-directory # --silent
+#MAKEFLAGS = --no-print-directory # --silent
 VPATH = ${Build} ${Pictures} ${Programs} # extra search path for file names used in document
 …
 BASE = ${basename ${DOCUMENT}}                  # remove suffix
+DemoTex = ${DemoSRC:%.cfa=${Build}/%.tex}
+RunPgmExe = ${addprefix ${Build}/,${basename ${basename ${RunPgmSRC}}}}
+RunPgmOut = ${RunPgmExe:%=%.out}
 # Commands
 LaTeX = TEXINPUTS=${TeXLIB} && export TEXINPUTS && pdflatex -halt-on-error -output-directory=${Build}
 BibTeX = BIBINPUTS=${BibLIB} && export BIBINPUTS && bibtex
+CFA = cfa
+CFA = cfa -O0 -g
+CC  = gcc -O0 -g
+CXX = g++-11 --std=c++20 -O0 -g
 # Rules and Recipes
+.PHONY : all clean                              # not file names
+.PHONY : all fragments_ran clean                        # not file names
+.PRECIOUS : ${Build}/% ${Build}/%-demo      # don't delete intermediates
 .ONESHELL :
+all : ${DOCUMENT}
+all : fragments_ran ${DOCUMENT}
+fragments_ran : $(RunPgmOut)
 clean :
 …
 # File Dependencies
 %.pdf : ${TeXSRC} ${DemoSRC:%.cfa=%.tex} ${PicSRC} ${PgmSRC} ${BibSRC} Makefile | ${Build}
+%.pdf : ${TeXSRC} ${DemoTex} ${PicSRC} ${PgmSRC} ${BibSRC} Makefile | ${Build}
         ${LaTeX} ${BASE}
         ${BibTeX} ${Build}/${BASE}
 …
 %-demo.tex: %-demo | ${Build}
         ${Build}/$< > ${Build}/$@
+        $< > $@
+%-demo: %-demo.cfa
         ${CFA} $< -o ${Build}/$@
+${Build}/%-demo: ${Programs}/%-demo.cfa | ${Build}
+        ${CFA} $< -o $@
+${Build}/%: ${Programs}/%.run.cfa | ${Build}
+        ${CFA} $< -o $@
+${Build}/%: ${Programs}/%.run.c | ${Build}
+        ${CC}  $< -o $@
+${Build}/%: ${Programs}/%.run.cpp | ${Build}
+        ${CXX} -MMD $< -o $@
+${Build}/%.out: ${Build}/% | ${Build}
+        $< > $@
+-include ${Build}/*.d

doc/theses/mike_brooks_MMath/uw-ethesis.bib

-              r34b4268
+              r24d6572
   bibsource = {dblp computer science bibliography, https://dblp.org}
+}
+% --------------------------------------------------
+% Linked-list prior work
+@misc{CFAStackEvaluation,
+    contributer = {a3moss@plg},
+    author      = {Aaron Moss},
+    title       = {\textsf{C}$\mathbf{\forall}$ Stack Evaluation Programs},
+    year        = 2018,
+    howpublished= {\href{https://cforall.uwaterloo.ca/CFAStackEvaluation.zip}{https://cforall.uwaterloo.ca/\-CFAStackEvaluation.zip}},
+}
+@misc{lst:linuxq,
+  title     = {queue(7) — Linux manual page},
+  howpublished= {\href{https://man7.org/linux/man-pages/man3/queue.3.html}{https://man7.org/linux/man-pages/man3/queue.3.html}},
+}
+  % see also https://man7.org/linux/man-pages/man7/queue.7.license.html
+  %          https://man7.org/tlpi/
+  %          https://www.kernel.org/doc/man-pages/
+@misc{lst:stl,
+  title     = {std::list},
+  howpublished= {\href{https://en.cppreference.com/w/cpp/container/list}{https://en.cppreference.com/w/cpp/container/list}},
+}

doc/theses/mike_brooks_MMath/uw-ethesis.tex

-              r34b4268
+              r24d6572
 % For hyperlinked PDF, suitable for viewing on a computer, use this:
 \documentclass[letterpaper,12pt,titlepage,oneside,final]{book}
+\usepackage{times}
 \usepackage[T1]{fontenc}        % Latin-1 => 256-bit characters, => | not dash, <> not Spanish question marks
 …
 \usepackage{comment} % Removes large sections of the document.
 \usepackage{tabularx}
+\usepackage{subfigure}
+\usepackage[labelformat=simple,aboveskip=0pt,farskip=0pt,font=normalsize]{subfig}
+\renewcommand\thesubfigure{(\alph{subfigure})}
 \usepackage{algorithm}
 …
     citecolor=blue,        % color of links to bibliography
     filecolor=magenta,      % color of file links
+    urlcolor=blue           % color of external links
+    urlcolor=blue,           % color of external links
+    breaklinks=true
+}
 \ifthenelse{\boolean{PrintVersion}}{   % for improved print quality, change some hyperref options
 …
 % although it's supposed to be in both the TeX Live and MikTeX distributions. There are also documentation and
 % installation instructions there.
+% Customizing tabularx
+\newcolumntype{Y}{>{\centering\arraybackslash}X}
 % Setting up the page margins...
 …
 \CFAStyle                                               % CFA code-style
 \lstset{language=CFA}                                   % default language
 \lstset{basicstyle=\linespread{0.9}\tt}                 % CFA typewriter font
+\lstset{basicstyle=\linespread{0.9}\sf}                 % CFA typewriter font
 \lstset{inputpath={programs}}
 \newcommand{\PAB}[1]{{\color{red}PAB: #1}}
+\newcommand{\uCpp}{$\mu$\CC}
 %======================================================================
 …
 %----------------------------------------------------------------------
 \begin{sloppypar}
 \input{intro}
 \input{background}
+\input{list}
 \input{array}
 \input{string}

driver/cfa.cc

-              r34b4268
+              r24d6572
 // Created On       : Tue Aug 20 13:44:49 2002
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed Jul 14 21:55:12 2021
 // Update Count     : 467
+// Last Modified On : Tue May 30 10:47:52 2023
+// Update Count     : 478
 //
 …
         static int flags = 0;
+    // This allocation 'leaks' memory from the program to the execution
+    // environment, as putenv does not manage the storage of the string used
+    // as an environment variable. This leak is necessary to ensure the
+    // underlying C string is allocated long enough.
         if ( putenv( (char *)( *new string( string( __CFA_FLAGPREFIX__ + to_string( flags++ ) + "__=" ) + arg ) ).c_str() ) ) {
                 cerr << argv[0] << " error, cannot set environment variable." << endl;
 …
                                 } // if
                         } else if ( arg == "-CFA" ) {
                                 CFA_flag = true;                                                // strip the -CFA flag
+                                CFA_flag = true;                                                // strip -CFA flag
                                 link = false;
                                 args[nargs++] = "-fsyntax-only";                // stop after stage 2
                         } else if ( arg == "-debug" ) {
                                 debug = true;                                                   // strip the debug flag
+                                debug = true;                                                   // strip debug flag
                         } else if ( arg == "-nodebug" ) {
                                 debug = false;                                                  // strip the nodebug flag
+                                debug = false;                                                  // strip nodebug flag
                         } else if ( arg == "-quiet" ) {
                                 quiet = true;                                                   // strip the quiet flag
+                                quiet = true;                                                   // strip quiet flag
                         } else if ( arg == "-noquiet" ) {
+                                quiet = false;                                                  // strip the noquiet flag
+                                quiet = false;                                                  // strip noquiet flag
+                        } else if ( arg == "-invariant" ) {
+                                Putenv( argv, "-" + arg );
+                        } else if ( arg == "--invariant" ) {
+                                Putenv( argv, arg );
                         } else if ( arg == "-no-include-stdhdr" ) {
                                 noincstd_flag = true;                                   // strip the no-include-stdhdr flag
+                                noincstd_flag = true;                                   // strip no-include-stdhdr flag
                         } else if ( arg == "-nolib" ) {
                                 nolib = true;                                                   // strip the nolib flag
+                                nolib = true;                                                   // strip nolib flag
                         } else if ( arg == "-help" ) {
                                 help = true;                                                    // strip the help flag
+                                help = true;                                                    // strip help flag
                         } else if ( arg == "-nohelp" ) {
                                 help = false;                                                   // strip the nohelp flag
+                                help = false;                                                   // strip nohelp flag
                         } else if ( arg == "-cfalib") {
                                 compiling_libs = true;
 …
                                 } // if
                         } else if ( prefix( arg, "-B" ) ) {
                                 bprefix = arg.substr(2);                                // strip the -B flag
+                                bprefix = arg.substr(2);                                // strip -B flag
                         } else if ( arg == "-c" || arg == "-S" || arg == "-E" || arg == "-M" || arg == "-MM" ) {
                                 args[nargs++] = argv[i];                                // pass flag along
 …
         #endif // __x86_64__
+        // ARM -mno-outline-atomics => use LL/SC instead of calls to atomic routines: __aarch64_swp_acq_rel, __aarch64_cas8_acq_rel
+        // ARM -march=armv8.2-a+lse => generate Arm LSE extension instructions SWAP and CAS
+        // https://community.arm.com/developer/tools-software/tools/b/tools-software-ides-blog/posts/making-the-most-of-the-arm-architecture-in-gcc-10
+        #ifdef __ARM_ARCH
+        args[nargs++] = "-mno-outline-atomics";                         // use ARM LL/SC instructions for atomics
+        #endif // __ARM_ARCH
         #ifdef __DEBUG_H__
         cerr << "args:";
 …
         args[nargs++] = "-fexceptions";                                         // add exception flags (unconditionally)
+        args[nargs++] = "-D_GNU_SOURCE";                                        // force gnu libraries
         // add flags based on the type of compile

libcfa/configure.ac

-              r34b4268
+              r24d6572
 AC_PROG_CC
 AM_PROG_AS
+AC_PROG_LIBTOOL
+LT_INIT
 AC_PROG_INSTALL
 AC_PROG_MAKE_SET
 …
 AC_CONFIG_HEADERS(prelude/defines.hfa)
 AC_OUTPUT()
+AC_OUTPUT
 # Final text

libcfa/prelude/builtins.c

-              r34b4268
+              r24d6572
 // Created On       : Fri Jul 21 16:21:03 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Aug 14 08:45:54 2021
 // Update Count     : 133
+// Last Modified On : Thu Feb  2 11:33:56 2023
+// Update Count     : 135
 //
 …
 static inline void ^?{}(generator$ &) {}
+trait is_generator(T &) {
+forall( T & )
+trait is_generator {
       void main(T & this);
       generator$ * get_generator(T & this);
 …
 static inline {
         long int ?\?( int x, unsigned int y ) { __CFA_EXP__(); }
+        int ?\?( int x, unsigned int y ) { __CFA_EXP__(); }
         long int ?\?( long int x, unsigned long int y ) { __CFA_EXP__(); }
         long long int ?\?( long long int x, unsigned long long int y ) { __CFA_EXP__(); }
         // unsigned computation may be faster and larger
         unsigned long int ?\?( unsigned int x, unsigned int y ) { __CFA_EXP__(); }
+        unsigned int ?\?( unsigned int x, unsigned int y ) { __CFA_EXP__(); }
         unsigned long int ?\?( unsigned long int x, unsigned long int y ) { __CFA_EXP__(); }
         unsigned long long int ?\?( unsigned long long int x, unsigned long long int y ) { __CFA_EXP__(); }
 …
 static inline {
         long int ?\=?( int & x, unsigned int y ) { x = x \ y; return x; }
+        int ?\=?( int & x, unsigned int y ) { x = x \ y; return x; }
         long int ?\=?( long int & x, unsigned long int y ) { x = x \ y; return x; }
         long long int ?\=?( long long int & x, unsigned long long int y ) { x = x \ y; return x; }
         unsigned long int ?\=?( unsigned int & x, unsigned int y ) { x = x \ y; return x; }
+        unsigned int ?\=?( unsigned int & x, unsigned int y ) { x = x \ y; return x; }
         unsigned long int ?\=?( unsigned long int & x, unsigned long int y ) { x = x \ y; return x; }
         unsigned long long int ?\=?( unsigned long long int & x, unsigned long long int y ) { x = x \ y; return x; }

libcfa/prelude/prelude-gen.cc

-              r34b4268
+              r24d6572
 // 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
+// Last Modified On : Thu Feb  2 11:40:01 2023
+// Update Count     : 38
 //
 …
 int main() {
         cout << "# 2 \"prelude.cfa\"  // needed for error messages from this file" << endl;
         cout << "trait sized(T &) {};" << endl;
+        cout << "forall( T & ) trait sized {};" << endl;
         cout << "//////////////////////////" << endl;

libcfa/src/Makefile.am

-              r34b4268
+              r24d6572
 ## Created On       : Sun May 31 08:54:01 2015
 ## Last Modified By : Peter A. Buhr
 ## Last Modified On : Fri Jul 16 16:00:40 2021
 ## Update Count     : 255
+## Last Modified On : Thu May 25 15:20:04 2023
+## Update Count     : 259
 ###############################################################################
 …
         math.hfa \
         time_t.hfa \
+        virtual_dtor.hfa \
         bits/algorithm.hfa \
         bits/align.hfa \
 …
         bits/queue.hfa \
         bits/sequence.hfa \
+        concurrency/atomic.hfa \
         concurrency/iofwd.hfa \
         concurrency/barrier.hfa \
 …
         concurrency/once.hfa \
         concurrency/kernel/fwd.hfa \
+        concurrency/mutex_stmt.hfa
+        concurrency/mutex_stmt.hfa \
+        concurrency/channel.hfa \
+        concurrency/actor.hfa
 inst_thread_headers_src = \
 …
         concurrency/monitor.hfa \
         concurrency/mutex.hfa \
+        concurrency/select.hfa \
         concurrency/thread.hfa

libcfa/src/algorithms/range_iterator.hfa

-              r34b4268
+              r24d6572
 // Author           : Thierry Delisle
 // Created On       : Tue Nov 30 13:06:22 2021
 // Last Modified By :
 // Last Modified On :
 // Update Count     :
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Mon Mar 13 23:10:35 2023
+// Update Count     : 1
 //
+#pragma once
 generator RangeIter {

libcfa/src/bitmanip.hfa

-              r34b4268
+              r24d6572
 // Created On       : Sat Mar 14 18:12:27 2020
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Oct  8 08:28:15 2022
 // Update Count     : 142
+// Last Modified On : Mon Jan  9 09:02:43 2023
+// Update Count     : 144
 //
 #pragma once
+#include "bits/debug.hfa"                                                               // verify
 // Reference: Bit Twiddling Hacks: http://graphics.stanford.edu/%7Eseander/bithacks.html#CountBitsSetNaive

libcfa/src/bits/containers.hfa

-              r34b4268
+              r24d6572
 // Created On       : Tue Oct 31 16:38:50 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed Jan 15 07:42:35 2020
 // Update Count     : 28
+// Last Modified On : Thu Feb  2 11:33:08 2023
+// Update Count     : 29
 #pragma once
 …
 #ifdef __cforall
+        trait is_node(T &) {
+        forall( T & )
+        trait is_node {
                 T *& get_next( T & );
         };

libcfa/src/bits/random.hfa

-              r34b4268
+              r24d6572
 // Created On       : Fri Jan 14 07:18:11 2022
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sun Dec 11 18:43:58 2022
 // Update Count     : 171
+// Last Modified On : Mon Mar 20 21:45:24 2023
+// Update Count     : 186
 //
 #pragma once
 #include <stdint.h>
+#include <stdint.h>                                                                             // uintXX_t
 #define GLUE2( x, y ) x##y
 …
 #ifdef __x86_64__                                                                               // 64-bit architecture
         // 64-bit generators
         #define LEHMER64
+        //#define LEHMER64
         //#define XORSHIFT_12_25_27
         //#define XOSHIRO256PP
+        #define XOSHIRO256PP
         //#define KISS_64
+    // #define SPLITMIX_64
         // 32-bit generators
+        #define XORSHIFT_6_21_7
+        //#define XOSHIRO128PP
+        //#define XORSHIFT_6_21_7
+        #define XOSHIRO128PP
+    // #define SPLITMIX_32
 #else                                                                                                   // 32-bit architecture
         // 64-bit generators
+        #define XORSHIFT_13_7_17
+        //#define XORSHIFT_13_7_17
+        #define XOSHIRO256PP
+    // #define SPLITMIX_64
         // 32-bit generators
+        #define XORSHIFT_6_21_7
+        //#define XORSHIFT_6_21_7
+        #define XOSHIRO128PP
+    // #define SPLITMIX_32
 #endif // __x86_64__
 // Define C/CFA PRNG name and random-state.
-// SKULLDUGGERY: typedefs name struct and typedef with the same name to deal with CFA typedef numbering problem.
 #ifdef XOSHIRO256PP
 #define PRNG_NAME_64 xoshiro256pp
 #define PRNG_STATE_64_T GLUE(PRNG_NAME_64,_t)
 typedef struct PRNG_STATE_64_T { uint64_t s[4]; } PRNG_STATE_64_T;
+typedef struct { uint64_t s0, s1, s2, s3; } PRNG_STATE_64_T;
 #endif // XOSHIRO256PP
 …
 #define PRNG_NAME_32 xoshiro128pp
 #define PRNG_STATE_32_T GLUE(PRNG_NAME_32,_t)
 typedef struct PRNG_STATE_32_T { uint32_t s[4]; } PRNG_STATE_32_T;
+typedef struct { uint32_t s0, s1, s2, s3; } PRNG_STATE_32_T;
 #endif // XOSHIRO128PP
 …
 #endif // XORSHIFT_12_25_27
+#ifdef SPLITMIX_64
+#define PRNG_NAME_64 splitmix64
+#define PRNG_STATE_64_T uint64_t
+#endif // SPLITMIX32
+#ifdef SPLITMIX_32
+#define PRNG_NAME_32 splitmix32
+#define PRNG_STATE_32_T uint32_t
+#endif // SPLITMIX32
 #ifdef KISS_64
 #define PRNG_NAME_64 kiss_64
 #define PRNG_STATE_64_T GLUE(PRNG_NAME_64,_t)
 typedef struct PRNG_STATE_64_T { uint64_t z, w, jsr, jcong; } PRNG_STATE_64_T;
+typedef struct { uint64_t z, w, jsr, jcong; } PRNG_STATE_64_T;
 #endif // KISS_^64
 …
 #define PRNG_NAME_32 xorwow
 #define PRNG_STATE_32_T GLUE(PRNG_NAME_32,_t)
 typedef struct PRNG_STATE_32_T { uint32_t a, b, c, d, counter; } PRNG_STATE_32_T;
+typedef struct { uint32_t a, b, c, d, counter; } PRNG_STATE_32_T;
 #endif // XOSHIRO128PP
 …
 // ALL PRNG ALGORITHMS ARE OPTIMIZED SO THAT THE PRNG LOGIC CAN HAPPEN IN PARALLEL WITH THE USE OF THE RESULT.
+// Therefore, the set_seed routine primes the PRNG by calling it with the state so the seed is not return as the
+// first random value.
+// Specifically, the current random state is copied for returning, before computing the next value.  As a consequence,
+// the set_seed routine primes the PRNG by calling it with the state so the seed is not return as the first random
+// value.
 #ifdef __cforall                                                                                // don't include in C code (invoke.h)
+// https://rosettacode.org/wiki/Pseudo-random_numbers/Splitmix64
+//
+// Splitmix64 is not recommended for demanding random number requirements, but is often used to calculate initial states
+// for other more complex pseudo-random number generators (see https://prng.di.unimi.it).
+// Also https://rosettacode.org/wiki/Pseudo-random_numbers/Splitmix64.
+static inline uint64_t splitmix64( uint64_t & state ) {
+    state += 0x9e3779b97f4a7c15;
+    uint64_t z = state;
+    z = (z ^ (z >> 30)) * 0xbf58476d1ce4e5b9;
+    z = (z ^ (z >> 27)) * 0x94d049bb133111eb;
+    return z ^ (z >> 31);
+} // splitmix64
+static inline void splitmix64_set_seed( uint64_t & state , uint64_t seed ) {
+    state = seed;
+    splitmix64( state );                                                                // prime
+} // splitmix64_set_seed
+// https://github.com/bryc/code/blob/master/jshash/PRNGs.md#splitmix32
+//
+// Splitmix32 is not recommended for demanding random number requirements, but is often used to calculate initial states
+// for other more complex pseudo-random number generators (see https://prng.di.unimi.it).
+static inline uint32_t splitmix32( uint32_t & state ) {
+    state += 0x9e3779b9;
+    uint64_t z = state;
+    z = (z ^ (z >> 15)) * 0x85ebca6b;
+    z = (z ^ (z >> 13)) * 0xc2b2ae35;
+    return z ^ (z >> 16);
+} // splitmix32
+static inline void splitmix32_set_seed( uint32_t & state, uint64_t seed ) {
+    state = seed;
+    splitmix32( state );                                                                // prime
+} // splitmix32_set_seed
+#ifdef __SIZEOF_INT128__
+//--------------------------------------------------
+static inline uint64_t lehmer64( __uint128_t & state ) {
+        __uint128_t ret = state;
+        state *= 0x_da94_2042_e4dd_58b5;
+        return ret >> 64;
+} // lehmer64
+static inline void lehmer64_set_seed( __uint128_t & state, uint64_t seed ) {
+        // The seed needs to be coprime with the 2^64 modulus to get the largest period, so no factors of 2 in the seed.
+        state = splitmix64( seed );                                                     // prime
+} // lehmer64_set_seed
+//--------------------------------------------------
+static inline uint64_t wyhash64( uint64_t & state ) {
+        uint64_t ret = state;
+        state += 0x_60be_e2be_e120_fc15;
+        __uint128_t tmp;
+        tmp = (__uint128_t) ret * 0x_a3b1_9535_4a39_b70d;
+        uint64_t m1 = (tmp >> 64) ^ tmp;
+        tmp = (__uint128_t)m1 * 0x_1b03_7387_12fa_d5c9;
+        uint64_t m2 = (tmp >> 64) ^ tmp;
+        return m2;
+} // wyhash64
+static inline void wyhash64_set_seed( uint64_t & state, uint64_t seed ) {
+        state = splitmix64( seed );                                                     // prime
+} // wyhash64_set_seed
+#endif // __SIZEOF_INT128__
 // https://prng.di.unimi.it/xoshiro256starstar.c
 …
 #ifndef XOSHIRO256PP
 typedef struct xoshiro256pp_t { uint64_t s[4]; } xoshiro256pp_t;
+typedef struct { uint64_t s0, s1, s2, s3; } xoshiro256pp_t;
 #endif // ! XOSHIRO256PP
 static inline uint64_t xoshiro256pp( xoshiro256pp_t & rs ) with(rs) {
         inline uint64_t rotl(const uint64_t x, int k) {
+        inline uint64_t rotl( const uint64_t x, int k ) {
                 return (x << k) | (x >> (64 - k));
         } // rotl
         const uint64_t result = rotl( s[0] + s[3], 23 ) + s[0];
         const uint64_t t = s[1] << 17;
         s[2] ^= s[0];
         s[3] ^= s[1];
         s[1] ^= s[2];
         s[0] ^= s[3];
         s[2] ^= t;
         s[3] = rotl( s[3], 45 );
+        const uint64_t result = rotl( s0 + s3, 23 ) + s0;
+        const uint64_t t = s1 << 17;
+        s2 ^= s0;
+        s3 ^= s1;
+        s1 ^= s2;
+        s0 ^= s3;
+        s2 ^= t;
+        s3 = rotl( s3, 45 );
         return result;
 } // xoshiro256pp
+static inline void xoshiro256pp_set_seed( xoshiro256pp_t & state,  uint64_t seed ) {
+        state = (xoshiro256pp_t){ {seed, seed, seed, seed} };
+        xoshiro256pp( state );
+static inline void xoshiro256pp_set_seed( xoshiro256pp_t & state, uint64_t seed ) {
+    // To attain repeatable seeding, compute seeds separately because the order of argument evaluation is undefined.
+    uint64_t seed1 = splitmix64( seed );                                // prime
+    uint64_t seed2 = splitmix64( seed );
+    uint64_t seed3 = splitmix64( seed );
+    uint64_t seed4 = splitmix64( seed );
+        state = (xoshiro256pp_t){ seed1, seed2, seed3, seed4 };
 } // xoshiro256pp_set_seed
 …
 #ifndef XOSHIRO128PP
 typedef struct xoshiro128pp_t { uint32_t s[4]; } xoshiro128pp_t;
+typedef struct { uint32_t s0, s1, s2, s3; } xoshiro128pp_t;
 #endif // ! XOSHIRO128PP
 …
         } // rotl
         const uint32_t result = rotl( s[0] + s[3], 7 ) + s[0];
         const uint32_t t = s[1] << 9;
         s[2] ^= s[0];
         s[3] ^= s[1];
         s[1] ^= s[2];
         s[0] ^= s[3];
         s[2] ^= t;
         s[3] = rotl( s[3], 11 );
+        const uint32_t result = rotl( s0 + s3, 7 ) + s0;
+        const uint32_t t = s1 << 9;
+        s2 ^= s0;
+        s3 ^= s1;
+        s1 ^= s2;
+        s0 ^= s3;
+        s2 ^= t;
+        s3 = rotl( s3, 11 );
         return result;
 } // xoshiro128pp
 static inline void xoshiro128pp_set_seed( xoshiro128pp_t & state, uint32_t seed ) {
+        state = (xoshiro128pp_t){ {seed, seed, seed, seed} };
+        xoshiro128pp( state );                                                          // prime
+    // To attain repeatable seeding, compute seeds separately because the order of argument evaluation is undefined.
+    uint32_t seed1 = splitmix32( seed );                                // prime
+    uint32_t seed2 = splitmix32( seed );
+    uint32_t seed3 = splitmix32( seed );
+    uint32_t seed4 = splitmix32( seed );
+        state = (xoshiro128pp_t){ seed1, seed2, seed3, seed4 };
 } // xoshiro128pp_set_seed
-#ifdef __SIZEOF_INT128__
-        // Pipelined to allow out-of-order overlap with reduced dependencies. Critically, the current random state is
-        // returned (copied), and then compute and store the next random value.
-        //--------------------------------------------------
-        static inline uint64_t lehmer64( __uint128_t & state ) {
-                __uint128_t ret = state;
-                state *= 0xda942042e4dd58b5;
-                return ret >> 64;
-        } // lehmer64
-        static inline void lehmer64_set_seed( __uint128_t & state, uint64_t seed ) {
-                state = seed;
-                lehmer64( state );
-        } // lehmer64_set_seed
-        //--------------------------------------------------
-        static inline uint64_t wyhash64( uint64_t & state ) {
-                uint64_t ret = state;
-                state += 0x_60be_e2be_e120_fc15;
-                __uint128_t tmp;
-                tmp = (__uint128_t) ret * 0x_a3b1_9535_4a39_b70d;
-                uint64_t m1 = (tmp >> 64) ^ tmp;
-                tmp = (__uint128_t)m1 * 0x_1b03_7387_12fa_d5c9;
-                uint64_t m2 = (tmp >> 64) ^ tmp;
-                return m2;
-        } // wyhash64
-        static inline void wyhash64_set_seed( uint64_t & state, uint64_t seed ) {
-                state = seed;
-                wyhash64( state );                                                              // prime
-        } // wyhash64_set_seed
-#endif // __SIZEOF_INT128__
 //--------------------------------------------------
 …
 static inline void xorshift_13_7_17_set_seed( uint64_t & state, uint64_t seed ) {
+        state = seed;
+        xorshift_13_7_17( state );                                                      // prime
+        state = splitmix64( seed );                                                     // prime
 } // xorshift_13_7_17_set_seed
 …
 static inline void xorshift_6_21_7_set_seed( uint32_t & state, uint32_t seed ) {
+        state = seed;
+        xorshift_6_21_7( state );                                                       // prime
+    state = splitmix32( seed );                                                 // prime
 } // xorshift_6_21_7_set_seed
 …
 static inline void xorshift_12_25_27_set_seed( uint64_t & state, uint64_t seed ) {
+        state = seed;
+        xorshift_12_25_27( state );                                                     // prime
+        state = splitmix64( seed );                                                     // prime
 } // xorshift_12_25_27_set_seed
 …
 // The state must be seeded with a nonzero value.
 #ifndef KISS_64
 typedef struct kiss_64_t { uint64_t z, w, jsr, jcong; } kiss_64_t;
+typedef struct { uint64_t z, w, jsr, jcong; } kiss_64_t;
 #endif // ! KISS_64
 static inline uint64_t kiss_64( kiss_64_t & state ) with(state) {
         kiss_64_t ret = state;
+static inline uint64_t kiss_64( kiss_64_t & rs ) with(rs) {
+        kiss_64_t ret = rs;
         z = 36969 * (z & 65535) + (z >> 16);
         w = 18000 * (w & 65535) + (w >> 16);
-        jsr ^= (jsr << 17);
         jsr ^= (jsr << 13);
+        jsr ^= (jsr >> 17);
         jsr ^= (jsr << 5);
         jcong = 69069 * jcong + 1234567;
 …
 } // kiss_64
+static inline void kiss_64_set_seed( kiss_64_t & state, uint64_t seed ) with(state) {
+        z = 1; w = 1; jsr = 4; jcong = seed;
+        kiss_64( state );                                                                       // prime
+static inline void kiss_64_set_seed( kiss_64_t & rs, uint64_t seed ) with(rs) {
+        z = 1; w = 1; jsr = 4; jcong = splitmix64( seed );      // prime
 } // kiss_64_set_seed
 …
 // The state array must be initialized to non-zero in the first four words.
 #ifndef XORWOW
 typedef struct xorwow_t { uint32_t a, b, c, d, counter; } xorwow_t;
+typedef struct { uint32_t a, b, c, d, counter; } xorwow_t;
 #endif // ! XORWOW
 static inline uint32_t xorwow( xorwow_t & state ) with(state) {
+static inline uint32_t xorwow( xorwow_t & rs ) with(rs) {
         // Algorithm "xorwow" from p. 5 of Marsaglia, "Xorshift RNGs".
         uint32_t ret = a + counter;
 …
 } // xorwow
+static inline void xorwow_set_seed( xorwow_t & state, uint32_t seed ) {
+        state = (xorwow_t){ seed, seed, seed, seed, 0 };
+        xorwow( state );                                                                        // prime
+static inline void xorwow_set_seed( xorwow_t & rs, uint32_t seed ) {
+    // To attain repeatable seeding, compute seeds separately because the order of argument evaluation is undefined.
+    uint32_t seed1 = splitmix32( seed );                                // prime
+    uint32_t seed2 = splitmix32( seed );
+    uint32_t seed3 = splitmix32( seed );
+    uint32_t seed4 = splitmix32( seed );
+        rs = (xorwow_t){ seed1, seed2, seed3, seed4, 0 };
 } // xorwow_set_seed
 …
 // Used in __tls_rand_fwd
 #define M  (1_l64u << 48_l64u)
 #define A  (25214903917_l64u)
 #define AI (18446708753438544741_l64u)
+#define A  (25_214_903_917_l64u)
+#define AI (18_446_708_753_438_544_741_l64u)
 #define C  (11_l64u)
 #define D  (16_l64u)
 // Bi-directional LCG random-number generator
 static inline uint32_t LCGBI_fwd( uint64_t & state ) {
         state = (A * state + C) & (M - 1);
         return state >> D;
+static inline uint32_t LCGBI_fwd( uint64_t & rs ) {
+        rs = (A * rs + C) & (M - 1);
+        return rs >> D;
 } // LCGBI_fwd
 static inline uint32_t LCGBI_bck( uint64_t & state ) {
         unsigned int r = state >> D;
         state = AI * (state - C) & (M - 1);
+static inline uint32_t LCGBI_bck( uint64_t & rs ) {
+        unsigned int r = rs >> D;
+        rs = AI * (rs - C) & (M - 1);
         return r;
 } // LCGBI_bck

libcfa/src/bits/weakso_locks.cfa

-              r34b4268
+              r24d6572
 // Update Count     :
 //
 #include "bits/weakso_locks.hfa"
 #pragma GCC visibility push(default)
 …
 void unlock( blocking_lock & ) {}
 void on_notify( blocking_lock &, struct thread$ * ) {}
 size_t on_wait( blocking_lock & ) { return 0; }
+size_t on_wait( blocking_lock &, void (*pp_fn)( void * ), void * pp_datum ) { return 0; }
 void on_wakeup( blocking_lock &, size_t ) {}
 size_t wait_count( blocking_lock & ) { return 0; }
+bool register_select( blocking_lock & this, select_node & node ) { return false; }
+bool unregister_select( blocking_lock & this, select_node & node ) { return false; }
+void on_selected( blocking_lock & this, select_node & node ) {}

libcfa/src/bits/weakso_locks.hfa

-              r34b4268
+              r24d6572
 #include "containers/list.hfa"
 struct thread$;
+struct select_node;
 //-----------------------------------------------------------------------------
 …
         // List of blocked threads
         dlist( thread$ ) blocked_threads;
+        dlist( select_node ) blocked_threads;
         // Count of current blocked threads
 …
 void unlock( blocking_lock & this ) OPTIONAL_THREAD;
 void on_notify( blocking_lock & this, struct thread$ * t ) OPTIONAL_THREAD;
 size_t on_wait( blocking_lock & this ) OPTIONAL_THREAD;
+size_t on_wait( blocking_lock & this, void (*pp_fn)( void * ), void * pp_datum ) OPTIONAL_THREAD;
 void on_wakeup( blocking_lock & this, size_t ) OPTIONAL_THREAD;
 size_t wait_count( blocking_lock & this ) OPTIONAL_THREAD;
+bool register_select( blocking_lock & this, select_node & node ) OPTIONAL_THREAD;
+bool unregister_select( blocking_lock & this, select_node & node ) OPTIONAL_THREAD;
+void on_selected( blocking_lock & this, select_node & node ) OPTIONAL_THREAD;
 //----------
 …
 static inline bool   try_lock ( multiple_acquisition_lock & this ) { return try_lock( (blocking_lock &)this ); }
 static inline void   unlock   ( multiple_acquisition_lock & this ) { unlock  ( (blocking_lock &)this ); }
 static inline size_t on_wait  ( multiple_acquisition_lock & this ) { return on_wait ( (blocking_lock &)this ); }
+static inline size_t on_wait  ( multiple_acquisition_lock & this, void (*pp_fn)( void * ), void * pp_datum ) { return on_wait ( (blocking_lock &)this, pp_fn, pp_datum ); }
 static inline void   on_wakeup( multiple_acquisition_lock & this, size_t v ) { on_wakeup ( (blocking_lock &)this, v ); }
 static inline void   on_notify( multiple_acquisition_lock & this, struct thread$ * t ){ on_notify( (blocking_lock &)this, t ); }
+static inline bool   register_select( multiple_acquisition_lock & this, select_node & node ) { return register_select( (blocking_lock &)this, node ); }
+static inline bool   unregister_select( multiple_acquisition_lock & this, select_node & node ) { return unregister_select( (blocking_lock &)this, node ); }
+static inline void   on_selected( multiple_acquisition_lock & this, select_node & node ) { on_selected( (blocking_lock &)this, node ); }

libcfa/src/common.hfa

-              r34b4268
+              r24d6572
 } // extern "C"
 static inline __attribute__((always_inline)) {
         unsigned char abs( signed char v ) { return abs( (int)v ); }
+        unsigned char abs( signed char v ) { return (int)abs( (int)v ); }
         // use default C routine for int
         unsigned long int abs( long int v ) { return labs( v ); }
 …
         unsigned int min( unsigned int v1, unsigned int v2 ) { return v1 < v2 ? v1 : v2; }
         long int min( long int v1, long int v2 ) { return v1 < v2 ? v1 : v2; }
         unsigned long int min( unsigned long int v1, unsigned int v2 ) { return v1 < v2 ? v1 : v2; }
+        unsigned long int min( unsigned long int v1, unsigned long int v2 ) { return v1 < v2 ? v1 : v2; }
         long long int min( long long int v1, long long int v2 ) { return v1 < v2 ? v1 : v2; }
         unsigned long long int min( unsigned long long int v1, unsigned int v2 ) { return v1 < v2 ? v1 : v2; }
+        unsigned long long int min( unsigned long long int v1, unsigned long long int v2 ) { return v1 < v2 ? v1 : v2; }
         forall( T | { int ?<?( T, T ); } )                                      // generic
         T min( T v1, T v2 ) { return v1 < v2 ? v1 : v2; }

libcfa/src/concurrency/clib/cfathread.cfa

-              r34b4268
+              r24d6572
 // #define EPOLL_FOR_SOCKETS
+#include <string.h>
 #include "fstream.hfa"
 #include "locks.hfa"
 …
 #include "time.hfa"
 #include "stdlib.hfa"
+#include "iofwd.hfa"
 #include "cfathread.h"
-extern "C" {
-                #include <string.h>
-                #include <errno.h>
+}
 extern void ?{}(processor &, const char[], cluster &, thread$ *);
 extern "C" {
+      extern void __cfactx_invoke_thread(void (*main)(void *), void * this);
+        extern int accept4(int sockfd, struct sockaddr *addr, socklen_t *addrlen, int flags);
+        extern void __cfactx_invoke_thread(void (*main)(void *), void * this);
+}
 …
         // Mutex
         struct cfathread_mutex {
                 linear_backoff_then_block_lock impl;
+                exp_backoff_then_block_lock impl;
         };
         int cfathread_mutex_init(cfathread_mutex_t *restrict mut, const cfathread_mutexattr_t *restrict) __attribute__((nonnull (1))) { *mut = new(); return 0; }
 …
         // Condition
         struct cfathread_condition {
                 condition_variable(linear_backoff_then_block_lock) impl;
+                condition_variable(exp_backoff_then_block_lock) impl;
         };
         int cfathread_cond_init(cfathread_cond_t *restrict cond, const cfathread_condattr_t *restrict) __attribute__((nonnull (1))) { *cond = new(); return 0; }
 …
+}
-#include <iofwd.hfa>
 extern "C" {
-        #include <unistd.h>
-        #include <sys/types.h>
-        #include <sys/socket.h>
         //--------------------
         // IO operations
 …
                 , protocol);
+        }
         int cfathread_bind(int socket, const struct sockaddr *address, socklen_t address_len) {
+        int cfathread_bind(int socket, __CONST_SOCKADDR_ARG address, socklen_t address_len) {
                 return bind(socket, address, address_len);
+        }
 …
+        }
         int cfathread_accept(int socket, struct sockaddr *restrict address, socklen_t *restrict address_len) {
+        int cfathread_accept(int socket, __SOCKADDR_ARG address, socklen_t *restrict address_len) {
                 #if defined(EPOLL_FOR_SOCKETS)
                         int ret;
 …
+        }
         int cfathread_connect(int socket, const struct sockaddr *address, socklen_t address_len) {
+        int cfathread_connect(int socket, __CONST_SOCKADDR_ARG address, socklen_t address_len) {
                 #if defined(EPOLL_FOR_SOCKETS)
                         int ret;

libcfa/src/concurrency/clib/cfathread.h

-              r34b4268
+              r24d6572
 // Author           : Thierry Delisle
 // Created On       : Tue Sep 22 15:31:20 2020
 // Last Modified By :
 // Last Modified On :
 // Update Count     :
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Mon Mar 13 23:48:40 2023
+// Update Count     : 7
 //
+#pragma once
 #if defined(__cforall) || defined(__cplusplus)
+#include <unistd.h>
+#include <errno.h>
+#include <sys/socket.h>
 extern "C" {
 #endif
-        #include <asm/types.h>
-        #include <errno.h>
-        #include <unistd.h>
         //--------------------
         // Basic types
 …
         } cfathread_mutexattr_t;
         typedef struct cfathread_mutex * cfathread_mutex_t;
         int cfathread_mutex_init(cfathread_mutex_t *restrict mut, const cfathread_mutexattr_t *restrict attr) __attribute__((nonnull (1)));
+        int cfathread_mutex_init(cfathread_mutex_t * restrict mut, const cfathread_mutexattr_t * restrict attr) __attribute__((nonnull (1)));
         int cfathread_mutex_destroy(cfathread_mutex_t *mut) __attribute__((nonnull (1)));
         int cfathread_mutex_lock(cfathread_mutex_t *mut) __attribute__((nonnull (1)));
 …
         //--------------------
         // IO operations
-        struct sockaddr;
-        struct msghdr;
         int cfathread_socket(int domain, int type, int protocol);
         int cfathread_bind(int socket, const struct sockaddr *address, socklen_t address_len);
+        int cfathread_bind(int socket, __CONST_SOCKADDR_ARG address, socklen_t address_len);
         int cfathread_listen(int socket, int backlog);
         int cfathread_accept(int socket, struct sockaddr *restrict address, socklen_t *restrict address_len);
         int cfathread_connect(int socket, const struct sockaddr *address, socklen_t address_len);
+        int cfathread_accept(int socket, __SOCKADDR_ARG address, socklen_t * restrict address_len);
+        int cfathread_connect(int socket, __CONST_SOCKADDR_ARG address, socklen_t address_len);
         int cfathread_dup(int fildes);
         int cfathread_close(int fildes);

libcfa/src/concurrency/coroutine.cfa

-              r34b4268
+              r24d6572
 // Created On       : Mon Nov 28 12:27:26 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Tue Dec 15 12:06:04 2020
 // Update Count     : 23
+// Last Modified On : Thu Feb 16 15:34:46 2023
+// Update Count     : 24
 //
 #define __cforall_thread__
-#define _GNU_SOURCE
 #include "coroutine.hfa"

libcfa/src/concurrency/coroutine.hfa

-              r34b4268
+              r24d6572
 // Created On       : Mon Nov 28 12:27:26 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Jan  6 16:33:16 2022
 // Update Count     : 12
+// Last Modified On : Thu Feb  2 11:31:42 2023
+// Update Count     : 13
 //
 …
 // Anything that implements this trait can be resumed.
 // Anything that is resumed is a coroutine.
+trait is_coroutine(T & | IS_RESUMPTION_EXCEPTION(CoroutineCancelled(T))) {
+forall( T & | IS_RESUMPTION_EXCEPTION(CoroutineCancelled(T)) )
+trait is_coroutine {
         void main(T & this);
         coroutine$ * get_coroutine(T & this);

libcfa/src/concurrency/future.hfa

-              r34b4268
+              r24d6572
 // file "LICENCE" distributed with Cforall.
 //
 // io/types.hfa --
 //
 // Author           : Thierry Delisle & Peiran Hong
+// concurrency/future.hfa --
+//
+// Author           : Thierry Delisle & Peiran Hong & Colby Parsons
 // Created On       : Wed Jan 06 17:33:18 2021
 // Last Modified By :
 …
 #include "bits/locks.hfa"
 #include "monitor.hfa"
+#include "select.hfa"
+#include "locks.hfa"
+//----------------------------------------------------------------------------
+// future
+// I don't use future_t here since I need to use a lock for this future
+//  since it supports multiple consumers
+//  future_t is lockfree and uses atomics which aren't needed given we use locks here
 forall( T ) {
+    // enum { FUTURE_EMPTY = 0, FUTURE_FULFILLED = 1 }; // Enums seem to be broken so feel free to add this back afterwards
+    // temporary enum replacement
+    const int FUTURE_EMPTY = 0;
+    const int FUTURE_FULFILLED = 1;
         struct future {
+                int state;
+                T result;
+                dlist( select_node ) waiters;
+        futex_mutex lock;
+        };
+    struct future_node {
+        inline select_node;
+        T * my_result;
+    };
+        static inline {
+        void ?{}( future_node(T) & this, thread$ * blocked_thread, T * my_result ) {
+            ((select_node &)this){ blocked_thread };
+            this.my_result = my_result;
+        }
+        void ?{}( future(T) & this ) {
+                        this.waiters{};
+            this.state = FUTURE_EMPTY;
+            this.lock{};
+                }
+                // Reset future back to original state
+                void reset( future(T) & this ) with(this)
+        {
+            lock( lock );
+            if( ! waiters`isEmpty )
+                abort("Attempting to reset a future with blocked waiters");
+            state = FUTURE_EMPTY;
+            unlock( lock );
+        }
+                // check if the future is available
+        // currently no mutual exclusion because I can't see when you need this call to be synchronous or protected
+                bool available( future(T) & this ) { return __atomic_load_n( &this.state, __ATOMIC_RELAXED ); }
+        // memcpy wrapper to help copy values
+        void copy_T( T & from, T & to ) {
+            memcpy((void *)&to, (void *)&from, sizeof(T));
+        }
+        // internal helper to signal waiters off of the future
+        void _internal_flush( future(T) & this ) with(this) {
+            while( ! waiters`isEmpty ) {
+                if ( !__handle_waituntil_OR( waiters ) ) // handle special waituntil OR case
+                    break; // if handle_OR returns false then waiters is empty so break
+                select_node &s = try_pop_front( waiters );
+                if ( s.clause_status == 0p ) // poke in result so that woken threads do not need to reacquire any locks
+                    copy_T( result, *(((future_node(T) &)s).my_result) );
+                wake_one( waiters, s );
+            }
+        }
+                // Fulfil the future, returns whether or not someone was unblocked
+                bool fulfil( future(T) & this, T val ) with(this) {
+            lock( lock );
+            if( state != FUTURE_EMPTY )
+                abort("Attempting to fulfil a future that has already been fulfilled");
+            copy_T( val, result );
+            bool ret_val = ! waiters`isEmpty;
+            state = FUTURE_FULFILLED;
+                        _internal_flush( this );
+            unlock( lock );
+            return ret_val;
+                }
+                // Wait for the future to be fulfilled
+                // Also return whether the thread had to block or not
+                [T, bool] get( future(T) & this ) with( this ) {
+            lock( lock );
+            T ret_val;
+            if( state == FUTURE_FULFILLED ) {
+                copy_T( result, ret_val );
+                unlock( lock );
+                return [ret_val, false];
+            }
+            future_node(T) node = { active_thread(), &ret_val };
+            insert_last( waiters, ((select_node &)node) );
+            unlock( lock );
+            park( );
+                        return [ret_val, true];
+                }
+                // Wait for the future to be fulfilled
+                T get( future(T) & this ) {
+                        [T, bool] tt;
+                        tt = get(this);
+                        return tt.0;
+                }
+        // Gets value if it is available and returns [ val, true ]
+        // otherwise returns [ default_val, false]
+        // will not block
+        [T, bool] try_get( future(T) & this ) with(this) {
+            lock( lock );
+            T ret_val;
+            if( state == FUTURE_FULFILLED ) {
+                copy_T( result, ret_val );
+                unlock( lock );
+                return [ret_val, true];
+            }
+            unlock( lock );
+            return [ret_val, false];
+        }
+        bool register_select( future(T) & this, select_node & s ) with(this) {
+            lock( lock );
+            // check if we can complete operation. If so race to establish winner in special OR case
+            if ( !s.park_counter && state != FUTURE_EMPTY ) {
+                if ( !__make_select_node_available( s ) ) { // we didn't win the race so give up on registering
+                    unlock( lock );
+                    return false;
+                }
+            }
+            // future not ready -> insert select node and return
+            if( state == FUTURE_EMPTY ) {
+                insert_last( waiters, s );
+                unlock( lock );
+                return false;
+            }
+            __make_select_node_available( s );
+            unlock( lock );
+            return true;
+        }
+        bool unregister_select( future(T) & this, select_node & s ) with(this) {
+            if ( ! s`isListed ) return false;
+            lock( lock );
+            if ( s`isListed ) remove( s );
+            unlock( lock );
+            return false;
+        }
+        void on_selected( future(T) & this, select_node & node ) {}
+        }
+}
+//--------------------------------------------------------------------------------------------------------
+// These futures below do not support select statements so they may not have as many features as 'future'
+//  however the 'single_future' is cheap and cheerful and is most likely more performant than 'future'
+//  since it uses raw atomics and no locks
+//
+// As far as 'multi_future' goes I can't see many use cases as it will be less performant than 'future'
+//  since it is monitor based and also is not compatible with select statements
+//--------------------------------------------------------------------------------------------------------
+forall( T ) {
+        struct single_future {
                 inline future_t;
                 T result;
 …
         static inline {
                 // Reset future back to original state
                 void reset(future(T) & this) { reset( (future_t&)this ); }
+                void reset(single_future(T) & this) { reset( (future_t&)this ); }
                 // check if the future is available
                 bool available( future(T) & this ) { return available( (future_t&)this ); }
+                bool available( single_future(T) & this ) { return available( (future_t&)this ); }
                 // Mark the future as abandoned, meaning it will be deleted by the server
                 // This doesn't work beause of the potential need for a destructor
                 void abandon( future(T) & this );
+                void abandon( single_future(T) & this );
                 // Fulfil the future, returns whether or not someone was unblocked
                 thread$ * fulfil( future(T) & this, T result ) {
+                thread$ * fulfil( single_future(T) & this, T result ) {
                         this.result = result;
                         return fulfil( (future_t&)this );
 …
                 // Wait for the future to be fulfilled
                 // Also return whether the thread had to block or not
                 [T, bool] wait( future(T) & this ) {
+                [T, bool] wait( single_future(T) & this ) {
                         bool r = wait( (future_t&)this );
                         return [this.result, r];
 …
                 // Wait for the future to be fulfilled
                 T wait( future(T) & this ) {
+                T wait( single_future(T) & this ) {
                         [T, bool] tt;
                         tt = wait(this);

libcfa/src/concurrency/invoke.h

-              r34b4268
+              r24d6572
 // Created On       : Tue Jan 17 12:27:26 2016
 // Last Modified By : Peter A. Buhr
+// Last Modified On : Tue Nov 29 20:42:21 2022
+// Update Count     : 56
+//
+// Last Modified On : Tue Mar 14 13:39:31 2023
+// Update Count     : 59
+//
+// No not use #pragma once was this file is included twice in some places. It has its own guard system.
 #include "bits/containers.hfa"
 …
                 struct __thread_user_link cltr_link;
-                // used to store state between clh lock/unlock
-                volatile bool * clh_prev;
-                // used to point to this thd's current clh node
-                volatile bool * clh_node;
                 struct processor * last_proc;
+        // ptr used during handover between blocking lists to allow for stack allocation of intrusive nodes
+        // main use case is wait-morphing to allow a different node to be used to block on condvar vs lock
+        void * link_node;
                 PRNG_STATE_T random_state;                                              // fast random numbers

libcfa/src/concurrency/io.cfa

-              r34b4268
+              r24d6572
 #define __cforall_thread__
-#define _GNU_SOURCE
 #if defined(__CFA_DEBUG__)
 …
         static io_context$ * __ioarbiter_allocate( io_arbiter$ & this, __u32 idxs[], __u32 want );
         static void __ioarbiter_submit( io_context$ * , __u32 idxs[], __u32 have, bool lazy );
         static void __ioarbiter_flush ( io_context$ & );
+        static void __ioarbiter_flush ( io_context$ &, bool kernel );
         static inline void __ioarbiter_notify( io_context$ & ctx );
 //=============================================================================================
 …
         extern void __kernel_unpark( thread$ * thrd, unpark_hint );
+        static inline void __post(oneshot & this, bool kernel, unpark_hint hint) {
+                thread$ * t = post( this, false );
+                if(kernel) __kernel_unpark( t, hint );
+                else unpark( t, hint );
+        }
+        // actual system call of io uring
+        // wrap so everything that needs to happen around it is always done
+        //   i.e., stats, book keeping, sqe reclamation, etc.
         static void ioring_syscsll( struct io_context$ & ctx, unsigned int min_comp, unsigned int flags ) {
                 __STATS__( true, io.calls.flush++; )
                 int ret;
                 for() {
+                        // do the system call in a loop, repeat on interrupts
                         ret = syscall( __NR_io_uring_enter, ctx.fd, ctx.sq.to_submit, min_comp, flags, (sigset_t *)0p, _NSIG / 8);
                         if( ret < 0 ) {
 …
                 /* paranoid */ verify( ctx.sq.to_submit >= ret );
+                ctx.sq.to_submit -= ret;
+                // keep track of how many still need submitting
+                __atomic_fetch_sub(&ctx.sq.to_submit, ret, __ATOMIC_SEQ_CST);
                 /* paranoid */ verify( ctx.sq.to_submit <= *ctx.sq.num );
 …
                 /* paranoid */ verify( ! __preemption_enabled() );
+                // mark that there is no pending io left
                 __atomic_store_n(&ctx.proc->io.pending, false, __ATOMIC_RELAXED);
+        }
+        // try to acquire an io context for draining, helping means we never *need* to drain, we can always do it later
         static bool try_acquire( io_context$ * ctx ) __attribute__((nonnull(1))) {
                 /* paranoid */ verify( ! __preemption_enabled() );
 …
+                {
+                        // if there is nothing to drain there is no point in acquiring anything
                         const __u32 head = *ctx->cq.head;
                         const __u32 tail = *ctx->cq.tail;
 …
+                }
+                // Drain the queue
+                if(!__atomic_try_acquire(&ctx->cq.lock)) {
+                // try a simple spinlock acquire, it's likely there are completions to drain
+                if(!__atomic_try_acquire(&ctx->cq.try_lock)) {
+                        // some other processor already has it
                         __STATS__( false, io.calls.locked++; )
                         return false;
+                }
+                // acquired!!
                 return true;
+        }
+        // actually drain the completion
         static bool __cfa_do_drain( io_context$ * ctx, cluster * cltr ) __attribute__((nonnull(1, 2))) {
                 /* paranoid */ verify( ! __preemption_enabled() );
                 /* paranoid */ verify( ready_schedule_islocked() );
+                /* paranoid */ verify( ctx->cq.lock == true );
+                /* paranoid */ verify( ctx->cq.try_lock == true );
+                // get all the invariants and initial state
                 const __u32 mask = *ctx->cq.mask;
                 const __u32 num  = *ctx->cq.num;
 …
                 for() {
                         // re-read the head and tail in case it already changed.
+                        // count the difference between the two
                         const __u32 head = *ctx->cq.head;
                         const __u32 tail = *ctx->cq.tail;
 …
                         __STATS__( false, io.calls.drain++; io.calls.completed += count; )
+                        // for everything between head and tail, drain it
                         for(i; count) {
                                 unsigned idx = (head + i) & mask;
 …
                                 /* paranoid */ verify(&cqe);
+                                // find the future in the completion
                                 struct io_future_t * future = (struct io_future_t *)(uintptr_t)cqe.user_data;
                                 // __cfadbg_print_safe( io, "Kernel I/O : Syscall completed : cqe %p, result %d for %p\n", &cqe, cqe.res, future );
+                                // don't directly fulfill the future, preemption is disabled so we need to use kernel_unpark
                                 __kernel_unpark( fulfil( *future, cqe.res, false ), UNPARK_LOCAL );
+                        }
+                        // update the timestamps accordingly
+                        // keep a local copy so we can update the relaxed copy
                         ts_next = ctx->cq.ts = rdtscl();
 …
                         ctx->proc->idle_wctx.drain_time = ts_next;
+                        // we finished draining the completions... unless the ring buffer was full and there are more secret completions in the kernel.
                         if(likely(count < num)) break;
+                        // the ring buffer was full, there could be more stuff in the kernel.
                         ioring_syscsll( *ctx, 0, IORING_ENTER_GETEVENTS);
+                }
 …
                 /* paranoid */ verify( ! __preemption_enabled() );
+                __atomic_unlock(&ctx->cq.lock);
+                // everything is drained, we can release the lock
+                __atomic_unlock(&ctx->cq.try_lock);
+                // update the relaxed timestamp
                 touch_tsc( cltr->sched.io.tscs, ctx->cq.id, ts_prev, ts_next, false );
 …
+        }
+        // call from a processor to flush
+        // contains all the bookkeeping a proc must do, not just the barebones flushing logic
+        void __cfa_do_flush( io_context$ & ctx, bool kernel ) {
+                /* paranoid */ verify( ! __preemption_enabled() );
+                // flush any external requests
+                ctx.sq.last_external = false; // clear the external bit, the arbiter will reset it if needed
+                __ioarbiter_flush( ctx, kernel );
+                // if submitting must be submitted, do the system call
+                if(ctx.sq.to_submit != 0) {
+                        ioring_syscsll(ctx, 0, 0);
+                }
+        }
+        // call from a processor to drain
+        // contains all the bookkeeping a proc must do, not just the barebones draining logic
         bool __cfa_io_drain( struct processor * proc ) {
                 bool local = false;
                 bool remote = false;
+                // make sure no ones creates/destroys io contexts
                 ready_schedule_lock();
 …
                 /* paranoid */ verify( ctx );
+                // Help if needed
                 with(cltr->sched) {
                         const size_t ctxs_count = io.count;
 …
                         const unsigned long long ctsc = rdtscl();
+                        // only help once every other time
+                        // pick a target when not helping
                         if(proc->io.target == UINT_MAX) {
                                 uint64_t chaos = __tls_rand();
+                                // choose who to help and whether to accept helping far processors
                                 unsigned ext = chaos & 0xff;
                                 unsigned other  = (chaos >> 8) % (ctxs_count);
+                                // if the processor is on the same cache line or is lucky ( 3 out of 256 odds ) help it
                                 if(ext < 3 || __atomic_load_n(&caches[other / __shard_factor.io].id, __ATOMIC_RELAXED) == this_cache) {
                                         proc->io.target = other;
 …
+                        }
                         else {
+                                // a target was picked last time, help it
                                 const unsigned target = proc->io.target;
                                 /* paranoid */ verify( io.tscs[target].t.tv != ULLONG_MAX );
+                                // make sure the target hasn't stopped existing since last time
                                 HELP: if(target < ctxs_count) {
+                                        // calculate it's age and how young it could be before we give up on helping
                                         const __readyQ_avg_t cutoff = calc_cutoff(ctsc, ctx->cq.id, ctxs_count, io.data, io.tscs, __shard_factor.io, false);
                                         const __readyQ_avg_t age = moving_average(ctsc, io.tscs[target].t.tv, io.tscs[target].t.ma, false);
                                         __cfadbg_print_safe(io, "Kernel I/O: Help attempt on %u from %u, age %'llu vs cutoff %'llu, %s\n", target, ctx->cq.id, age, cutoff, age > cutoff ? "yes" : "no");
+                                        // is the target older than the cutoff, recall 0 is oldest and bigger ints are younger
                                         if(age <= cutoff) break HELP;
+                                        if(!try_acquire(io.data[target])) break HELP;
+                                        // attempt to help the submission side
+                                        __cfa_do_flush( *io.data[target], true );
+                                        // attempt to help the completion side
+                                        if(!try_acquire(io.data[target])) break HELP; // already acquire no help needed
+                                        // actually help
                                         if(!__cfa_do_drain( io.data[target], cltr )) break HELP;
+                                        // track we did help someone
                                         remote = true;
                                         __STATS__( true, io.calls.helped++; )
+                                }
+                                // reset the target
                                 proc->io.target = UINT_MAX;
+                        }
+                }
                 // Drain the local queue
 …
                 ready_schedule_unlock();
+                // return true if some completion entry, local or remote, was drained
                 return local || remote;
+        }
+        // call from a processor to flush
+        // contains all the bookkeeping a proc must do, not just the barebones flushing logic
         bool __cfa_io_flush( struct processor * proc ) {
                 /* paranoid */ verify( ! __preemption_enabled() );
 …
                 /* paranoid */ verify( proc->io.ctx );
+                io_context$ & ctx = *proc->io.ctx;
+                __ioarbiter_flush( ctx );
+                if(ctx.sq.to_submit != 0) {
+                        ioring_syscsll(ctx, 0, 0);
+                }
+                __cfa_do_flush( *proc->io.ctx, false );
+                // also drain since some stuff will immediately complete
                 return __cfa_io_drain( proc );
+        }
 …
         //=============================================================================================
         // submission
+        static inline void __submit_only( struct io_context$ * ctx, __u32 idxs[], __u32 have) {
+        // barebones logic to submit a group of sqes
+        static inline void __submit_only( struct io_context$ * ctx, __u32 idxs[], __u32 have, bool lock) {
+                if(!lock)
+                        lock( ctx->ext_sq.lock __cfaabi_dbg_ctx2 );
                 // We can proceed to the fast path
                 // Get the right objects
 …
                 // Make the sqes visible to the submitter
                 __atomic_store_n(sq.kring.tail, tail + have, __ATOMIC_RELEASE);
+                sq.to_submit += have;
+                __atomic_fetch_add(&sq.to_submit, have, __ATOMIC_SEQ_CST);
+                // set the bit to mark things need to be flushed
                 __atomic_store_n(&ctx->proc->io.pending, true, __ATOMIC_RELAXED);
                 __atomic_store_n(&ctx->proc->io.dirty  , true, __ATOMIC_RELAXED);
+        }
+                if(!lock)
+                        unlock( ctx->ext_sq.lock );
+        }
+        // submission logic + maybe flushing
         static inline void __submit( struct io_context$ * ctx, __u32 idxs[], __u32 have, bool lazy) {
                 __sub_ring_t & sq = ctx->sq;
                 __submit_only(ctx, idxs, have);
+                __submit_only(ctx, idxs, have, false);
                 if(sq.to_submit > 30) {
 …
+        }
+        // call from a processor to flush
+        // might require arbitration if the thread was migrated after the allocation
         void cfa_io_submit( struct io_context$ * inctx, __u32 idxs[], __u32 have, bool lazy ) __attribute__((nonnull (1))) libcfa_public {
                 // __cfadbg_print_safe(io, "Kernel I/O : attempting to submit %u (%s)\n", have, lazy ? "lazy" : "eager");
 …
                 if( ctx == inctx )              // We have the right instance?
+                {
+                        // yes! fast submit
                         __submit(ctx, idxs, have, lazy);
 …
                 __atomic_store_n(&ctx.sq.free_ring.tail, ftail + count, __ATOMIC_SEQ_CST);
+                // notify the allocator that new allocations can be made
                 __ioarbiter_notify(ctx);
 …
+        }
+        // notify the arbiter that new allocations are available
         static void __ioarbiter_notify( io_arbiter$ & this, io_context$ * ctx ) {
                 /* paranoid */ verify( !empty(this.pending.queue) );
+                /* paranoid */ verify( __preemption_enabled() );
+                // mutual exclusion is needed
                 lock( this.pending.lock __cfaabi_dbg_ctx2 );
+                {
+                        __cfadbg_print_safe(io, "Kernel I/O : notifying\n");
+                        // as long as there are pending allocations try to satisfy them
+                        // for simplicity do it in FIFO order
                         while( !empty(this.pending.queue) ) {
                                 __cfadbg_print_safe(io, "Kernel I/O : notifying\n");
+                                // get first pending allocs
                                 __u32 have = ctx->sq.free_ring.tail - ctx->sq.free_ring.head;
                                 __pending_alloc & pa = (__pending_alloc&)head( this.pending.queue );
+                                // check if we have enough to satisfy the request
                                 if( have > pa.want ) goto DONE;
+                                // if there are enough allocations it means we can drop the request
                                 drop( this.pending.queue );
                                 /* paranoid */__attribute__((unused)) bool ret =
+                                // actually do the alloc
                                 __alloc(ctx, pa.idxs, pa.want);
                                 /* paranoid */ verify( ret );
+                                // write out which context statisfied the request and post
+                                // this
                                 pa.ctx = ctx;
                                 post( pa.waitctx );
+                        }
 …
+                }
                 unlock( this.pending.lock );
+        }
+                /* paranoid */ verify( __preemption_enabled() );
+        }
+        // short hand to avoid the mutual exclusion of the pending is empty regardless
         static void __ioarbiter_notify( io_context$ & ctx ) {
+                if(!empty( ctx.arbiter->pending )) {
+                        __ioarbiter_notify( *ctx.arbiter, &ctx );
+                }
+        }
+        // Simply append to the pending
+                if(empty( ctx.arbiter->pending )) return;
+                __ioarbiter_notify( *ctx.arbiter, &ctx );
+        }
+        // Submit from outside the local processor: append to the outstanding list
         static void __ioarbiter_submit( io_context$ * ctx, __u32 idxs[], __u32 have, bool lazy ) {
                 __cfadbg_print_safe(io, "Kernel I/O : submitting %u from the arbiter to context %u\n", have, ctx->fd);
 …
                 __cfadbg_print_safe(io, "Kernel I/O : waiting to submit %u\n", have);
+                // create the intrusive object to append
                 __external_io ei;
                 ei.idxs = idxs;
 …
                 ei.lazy = lazy;
+                // enqueue the io
                 bool we = enqueue(ctx->ext_sq, (__outstanding_io&)ei);
+                // mark pending
                 __atomic_store_n(&ctx->proc->io.pending, true, __ATOMIC_SEQ_CST);
+                // if this is the first to be enqueued, signal the processor in an attempt to speed up flushing
+                // if it's not the first enqueue, a signal is already in transit
                 if( we ) {
                         sigval_t value = { PREEMPT_IO };
                         __cfaabi_pthread_sigqueue(ctx->proc->kernel_thread, SIGUSR1, value);
+                }
+                        __STATS__( false, io.flush.signal += 1; )
+                }
+                __STATS__( false, io.submit.extr += 1; )
+                // to avoid dynamic allocation/memory reclamation headaches, wait for it to have been submitted
                 wait( ei.waitctx );
 …
+        }
+        static void __ioarbiter_flush( io_context$ & ctx ) {
+                if(!empty( ctx.ext_sq )) {
+                        __STATS__( false, io.flush.external += 1; )
+                        __cfadbg_print_safe(io, "Kernel I/O : arbiter flushing\n");
+                        lock( ctx.ext_sq.lock __cfaabi_dbg_ctx2 );
+                        {
+                                while( !empty(ctx.ext_sq.queue) ) {
+                                        __external_io & ei = (__external_io&)drop( ctx.ext_sq.queue );
+                                        __submit_only(&ctx, ei.idxs, ei.have);
+                                        post( ei.waitctx );
+                                }
+                                ctx.ext_sq.empty = true;
+        // flush the io arbiter: move all external io operations to the submission ring
+        static void __ioarbiter_flush( io_context$ & ctx, bool kernel ) {
+                // if there are no external operations just return
+                if(empty( ctx.ext_sq )) return;
+                // stats and logs
+                __STATS__( false, io.flush.external += 1; )
+                __cfadbg_print_safe(io, "Kernel I/O : arbiter flushing\n");
+                // this can happen from multiple processors, mutual exclusion is needed
+                lock( ctx.ext_sq.lock __cfaabi_dbg_ctx2 );
+                {
+                        // pop each operation one at a time.
+                        // There is no wait morphing because of the io sq ring
+                        while( !empty(ctx.ext_sq.queue) ) {
+                                // drop the element from the queue
+                                __external_io & ei = (__external_io&)drop( ctx.ext_sq.queue );
+                                // submit it
+                                __submit_only(&ctx, ei.idxs, ei.have, true);
+                                // wake the thread that was waiting on it
+                                // since this can both be called from kernel and user, check the flag before posting
+                                __post( ei.waitctx, kernel, UNPARK_LOCAL );
+                        }
+                        unlock(ctx.ext_sq.lock );
+                        // mark the queue as empty
+                        ctx.ext_sq.empty = true;
+                        ctx.sq.last_external = true;
+                }
+                unlock(ctx.ext_sq.lock );
+        }
+        extern "C" {
+                // debug functions used for gdb
+                // io_uring doesn't yet support gdb soe the kernel-shared data structures aren't viewable in gdb
+                // these functions read the data that gdb can't and should be removed once the support is added
+                static __u32 __cfagdb_cq_head( io_context$ * ctx ) __attribute__((nonnull(1),used,noinline)) { return *ctx->cq.head; }
+                static __u32 __cfagdb_cq_tail( io_context$ * ctx ) __attribute__((nonnull(1),used,noinline)) { return *ctx->cq.tail; }
+                static __u32 __cfagdb_cq_mask( io_context$ * ctx ) __attribute__((nonnull(1),used,noinline)) { return *ctx->cq.mask; }
+                static __u32 __cfagdb_sq_head( io_context$ * ctx ) __attribute__((nonnull(1),used,noinline)) { return *ctx->sq.kring.head; }
+                static __u32 __cfagdb_sq_tail( io_context$ * ctx ) __attribute__((nonnull(1),used,noinline)) { return *ctx->sq.kring.tail; }
+                static __u32 __cfagdb_sq_mask( io_context$ * ctx ) __attribute__((nonnull(1),used,noinline)) { return *ctx->sq.mask; }
+                // fancier version that reads an sqe and copies it out.
+                static struct io_uring_sqe __cfagdb_sq_at( io_context$ * ctx, __u32 at ) __attribute__((nonnull(1),used,noinline)) {
+                        __u32 ax = at & *ctx->sq.mask;
+                        __u32 ix = ctx->sq.kring.array[ax];
+                        return ctx->sq.sqes[ix];
+                }
+        }

libcfa/src/concurrency/io/call.cfa.in

-              r34b4268
+              r24d6572
 Prelude = """#define __cforall_thread__
+#include <unistd.h>
+#include <errno.h>
+#include <sys/socket.h>
+#include <time.hfa>
 #include "bits/defs.hfa"
 #include "kernel.hfa"
 …
         #include <assert.h>
         #include <stdint.h>
-        #include <errno.h>
         #include <linux/io_uring.h>
         #include "kernel/fwd.hfa"
 …
 // I/O Forwards
 //=============================================================================================
-#include <time.hfa>
-// Some forward declarations
-#include <errno.h>
-#include <unistd.h>
 extern "C" {
-        #include <asm/types.h>
-        #include <sys/socket.h>
-        #include <sys/syscall.h>
 #if defined(CFA_HAVE_PREADV2)
         struct iovec;
         extern ssize_t preadv2 (int fd, const struct iovec *iov, int iovcnt, off_t offset, int flags);
+        extern ssize_t preadv2 (int fd, const struct iovec * iov, int iovcnt, off_t offset, int flags);
 #endif
 #if defined(CFA_HAVE_PWRITEV2)
         struct iovec;
         extern ssize_t pwritev2(int fd, const struct iovec *iov, int iovcnt, off_t offset, int flags);
+        extern ssize_t pwritev2(int fd, const struct iovec * iov, int iovcnt, off_t offset, int flags);
 #endif
 …
         struct msghdr;
         struct sockaddr;
+        extern ssize_t sendmsg(int sockfd, const struct msghdr *msg, int flags);
+        extern ssize_t recvmsg(int sockfd, struct msghdr *msg, int flags);
+        extern ssize_t send(int sockfd, const void *buf, size_t len, int flags);
+        extern ssize_t recv(int sockfd, void *buf, size_t len, int flags);
+        extern int accept4(int sockfd, struct sockaddr *addr, socklen_t *addrlen, int flags);
+        extern int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen);
+        extern ssize_t sendmsg(int sockfd, const struct msghdr * msg, int flags);
+        extern ssize_t recvmsg(int sockfd, struct msghdr * msg, int flags);
+        extern ssize_t send(int sockfd, const void * buf, size_t len, int flags);
+        extern ssize_t recv(int sockfd, void * buf, size_t len, int flags);
         extern int fallocate(int fd, int mode, off_t offset, off_t len);
         extern int posix_fadvise(int fd, off_t offset, off_t len, int advice);
         extern int madvise(void *addr, size_t length, int advice);
         extern int openat(int dirfd, const char *pathname, int flags, mode_t mode);
+        extern int madvise(void * addr, size_t length, int advice);
+        extern int openat(int dirfd, const char * pathname, int flags, mode_t mode);
         extern int close(int fd);
         extern ssize_t read (int fd, void *buf, size_t count);
+        extern ssize_t read (int fd, void * buf, size_t count);
         struct epoll_event;
         extern int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);
         extern ssize_t splice(int fd_in, __off64_t *off_in, int fd_out, __off64_t *off_out, size_t len, unsigned int flags);
+        extern int epoll_ctl(int epfd, int op, int fd, struct epoll_event * event);
+        extern ssize_t splice(int fd_in, __off64_t * off_in, int fd_out, __off64_t * off_out, size_t len, unsigned int flags);
         extern ssize_t tee(int fd_in, int fd_out, size_t len, unsigned int flags);
+}
 …
 calls = [
         # CFA_HAVE_IORING_OP_READV
         Call('READV', 'ssize_t preadv2(int fd, const struct iovec *iov, int iovcnt, off_t offset, int flags)', {
+        Call('READV', 'ssize_t preadv2(int fd, const struct iovec * iov, int iovcnt, off_t offset, int flags)', {
                 'fd'  : 'fd',
+                'addr': '(typeof(sqe->addr))iov',
+                'len' : 'iovcnt',
                 'off' : 'offset',
+                'addr': '(uintptr_t)iov',
+                'len' : 'iovcnt',
+                'rw_flags' : 'flags'
         }, define = 'CFA_HAVE_PREADV2'),
         # CFA_HAVE_IORING_OP_WRITEV
         Call('WRITEV', 'ssize_t pwritev2(int fd, const struct iovec *iov, int iovcnt, off_t offset, int flags)', {
+        Call('WRITEV', 'ssize_t pwritev2(int fd, const struct iovec * iov, int iovcnt, off_t offset, int flags)', {
                 'fd'  : 'fd',
+                'addr': '(typeof(sqe->addr))iov',
+                'len' : 'iovcnt',
                 'off' : 'offset',
+                'addr': '(uintptr_t)iov',
+                'len' : 'iovcnt'
+                'rw_flags' : 'flags'
         }, define = 'CFA_HAVE_PWRITEV2'),
         # CFA_HAVE_IORING_OP_FSYNC
 …
         }),
         # CFA_HAVE_IORING_OP_EPOLL_CTL
         Call('EPOLL_CTL', 'int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event)', {
+        Call('EPOLL_CTL', 'int epoll_ctl(int epfd, int op, int fd, struct epoll_event * event)', {
                 'fd': 'epfd',
+                'len': 'op',
                 'addr': 'fd',
+                'len': 'op',
+                'off': '(uintptr_t)event'
+                'off': '(typeof(sqe->off))event'
         }),
         # CFA_HAVE_IORING_OP_SYNC_FILE_RANGE
 …
         }),
         # CFA_HAVE_IORING_OP_SENDMSG
         Call('SENDMSG', 'ssize_t sendmsg(int sockfd, const struct msghdr *msg, int flags)', {
                 'fd': 'sockfd',
                 'addr': '(uintptr_t)(struct msghdr *)msg',
+        Call('SENDMSG', 'ssize_t sendmsg(int sockfd, const struct msghdr * msg, int flags)', {
+                'fd': 'sockfd',
+                'addr': '(typeof(sqe->addr))(struct msghdr *)msg',
                 'len': '1',
                 'msg_flags': 'flags'
         }),
         # CFA_HAVE_IORING_OP_RECVMSG
         Call('RECVMSG', 'ssize_t recvmsg(int sockfd, struct msghdr *msg, int flags)', {
                 'fd': 'sockfd',
                 'addr': '(uintptr_t)(struct msghdr *)msg',
+        Call('RECVMSG', 'ssize_t recvmsg(int sockfd, struct msghdr * msg, int flags)', {
+                'fd': 'sockfd',
+                'addr': '(typeof(sqe->addr))(struct msghdr *)msg',
                 'len': '1',
                 'msg_flags': 'flags'
         }),
         # CFA_HAVE_IORING_OP_SEND
         Call('SEND', 'ssize_t send(int sockfd, const void *buf, size_t len, int flags)', {
                 'fd': 'sockfd',
                 'addr': '(uintptr_t)buf',
+        Call('SEND', 'ssize_t send(int sockfd, const void * buf, size_t len, int flags)', {
+                'fd': 'sockfd',
+                'addr': '(typeof(sqe->addr))buf',
                 'len': 'len',
                 'msg_flags': 'flags'
         }),
         # CFA_HAVE_IORING_OP_RECV
         Call('RECV', 'ssize_t recv(int sockfd, void *buf, size_t len, int flags)', {
                 'fd': 'sockfd',
                 'addr': '(uintptr_t)buf',
+        Call('RECV', 'ssize_t recv(int sockfd, void * buf, size_t len, int flags)', {
+                'fd': 'sockfd',
+                'addr': '(typeof(sqe->addr))buf',
                 'len': 'len',
                 'msg_flags': 'flags'
         }),
         # CFA_HAVE_IORING_OP_ACCEPT
         Call('ACCEPT', 'int accept4(int sockfd, struct sockaddr *addr, socklen_t *addrlen, int flags)', {
                 'fd': 'sockfd',
                 'addr': '(uintptr_t)addr',
                 'addr2': '(uintptr_t)addrlen',
+        Call('ACCEPT', 'int accept4(int sockfd, __SOCKADDR_ARG addr, socklen_t * restrict addrlen, int flags)', {
+                'fd': 'sockfd',
+                'addr': '(typeof(sqe->addr))&addr',
+                'addr2': '(typeof(sqe->addr2))addrlen',
                 'accept_flags': 'flags'
         }),
         # CFA_HAVE_IORING_OP_CONNECT
         Call('CONNECT', 'int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen)', {
                 'fd': 'sockfd',
                 'addr': '(uintptr_t)addr',
+        Call('CONNECT', 'int connect(int sockfd, __CONST_SOCKADDR_ARG addr, socklen_t addrlen)', {
+                'fd': 'sockfd',
+                'addr': '(typeof(sqe->addr))&addr',
                 'off': 'addrlen'
         }),
 …
         Call('FALLOCATE', 'int fallocate(int fd, int mode, off_t offset, off_t len)', {
                 'fd': 'fd',
-                'addr': '(uintptr_t)len',
                 'len': 'mode',
+                'off': 'offset'
+                'off': 'offset',
+                'addr': 'len'
         }),
         # CFA_HAVE_IORING_OP_FADVISE
 …
         }),
         # CFA_HAVE_IORING_OP_MADVISE
         Call('MADVISE', 'int madvise(void *addr, size_t length, int advice)', {
                 'addr': '(uintptr_t)addr',
+        Call('MADVISE', 'int madvise(void * addr, size_t length, int advice)', {
+                'addr': '(typeof(sqe->addr))addr',
                 'len': 'length',
                 'fadvise_advice': 'advice'
         }),
         # CFA_HAVE_IORING_OP_OPENAT
         Call('OPENAT', 'int openat(int dirfd, const char *pathname, int flags, mode_t mode)', {
+        Call('OPENAT', 'int openat(int dirfd, const char * pathname, int flags, mode_t mode)', {
                 'fd': 'dirfd',
                 'addr': '(uintptr_t)pathname',
                 'len': 'mode',
                 'open_flags': 'flags;'
+                'addr': '(typeof(sqe->addr))pathname',
+                'open_flags': 'flags;',
+                'len': 'mode'
         }),
         # CFA_HAVE_IORING_OP_OPENAT2
         Call('OPENAT2', 'int openat2(int dirfd, const char *pathname, struct open_how * how, size_t size)', {
+        Call('OPENAT2', 'int openat2(int dirfd, const char * pathname, struct open_how * how, size_t size)', {
                 'fd': 'dirfd',
                 'addr': 'pathname',
                 'len': 'sizeof(*how)',
                 'off': '(uintptr_t)how',
+                'addr': '(typeof(sqe->addr))pathname',
+                'off': '(typeof(sqe->off))how',
+                'len': 'sizeof(*how)'
         }, define = 'CFA_HAVE_OPENAT2'),
         # CFA_HAVE_IORING_OP_CLOSE
 …
         }),
         # CFA_HAVE_IORING_OP_STATX
         Call('STATX', 'int statx(int dirfd, const char *pathname, int flags, unsigned int mask, struct statx *statxbuf)', {
+        Call('STATX', 'int statx(int dirfd, const char * pathname, int flags, unsigned int mask, struct statx * statxbuf)', {
                 'fd': 'dirfd',
                 'off': '(uintptr_t)statxbuf',
                 'addr': 'pathname',
+                'addr': '(typeof(sqe->addr))pathname',
+                'statx_flags': 'flags',
                 'len': 'mask',
                 'statx_flags': 'flags'
+                'off': '(typeof(sqe->off))statxbuf'
         }, define = 'CFA_HAVE_STATX'),
         # CFA_HAVE_IORING_OP_READ
         Call('READ', 'ssize_t read(int fd, void * buf, size_t count)', {
                 'fd': 'fd',
                 'addr': '(uintptr_t)buf',
+                'addr': '(typeof(sqe->addr))buf',
                 'len': 'count'
         }),
 …
         Call('WRITE', 'ssize_t write(int fd, void * buf, size_t count)', {
                 'fd': 'fd',
                 'addr': '(uintptr_t)buf',
+                'addr': '(typeof(sqe->addr))buf',
                 'len': 'count'
         }),
         # CFA_HAVE_IORING_OP_SPLICE
         Call('SPLICE', 'ssize_t splice(int fd_in, __off64_t *off_in, int fd_out, __off64_t *off_out, size_t len, unsigned int flags)', {
+        Call('SPLICE', 'ssize_t splice(int fd_in, __off64_t * off_in, int fd_out, __off64_t * off_out, size_t len, unsigned int flags)', {
                 'splice_fd_in': 'fd_in',
                 'splice_off_in': 'off_in ? (__u64)*off_in : (__u64)-1',
+                'splice_off_in': 'off_in ? (typeof(sqe->splice_off_in))*off_in : (typeof(sqe->splice_off_in))-1',
                 'fd': 'fd_out',
                 'off': 'off_out ? (__u64)*off_out : (__u64)-1',
+                'off': 'off_out ? (typeof(sqe->off))*off_out : (typeof(sqe->off))-1',
                 'len': 'len',
                 'splice_flags': 'flags'

libcfa/src/concurrency/io/setup.cfa

-              r34b4268
+              r24d6572
 #define __cforall_thread__
-#define _GNU_SOURCE
 #if defined(__CFA_DEBUG__)
 …
                 // completion queue
                 cq.lock      = false;
+                cq.try_lock  = false;
                 cq.id        = MAX;
                 cq.ts        = rdtscl();

libcfa/src/concurrency/io/types.hfa

-              r34b4268
+              r24d6572
         //-----------------------------------------------------------------------
         // Ring Data structure
+      struct __sub_ring_t {
+        // represent the io_uring submission ring which contains operations that will be sent to io_uring for processing
+        struct __sub_ring_t {
+                // lock needed because remote processors might need to flush the instance
+                __spinlock_t lock;
                 struct {
                         // Head and tail of the ring (associated with array)
 …
                 // number of sqes to submit on next system call.
                 __u32 to_submit;
+                volatile __u32 to_submit;
                 // number of entries and mask to go with it
 …
                 void * ring_ptr;
                 size_t ring_sz;
+        };
+                // for debug purposes, whether or not the last flush was due to a arbiter flush
+                bool last_external;
+        };
+        // represent the io_uring completion ring which contains operations that have completed
         struct __cmp_ring_t {
+                volatile bool lock;
+                // needed because remote processors can help drain the buffer
+                volatile bool try_lock;
+                // id of the ring, used for the helping/topology algorithms
                 unsigned id;
+                // timestamp from last time it was drained
                 unsigned long long ts;
 …
         };
+        // struct representing an io operation that still needs processing
+        // actual operations are expected to inherit from this
         struct __outstanding_io {
+                // intrusive link fields
                 inline Colable;
+                // primitive on which to block until the io is processed
                 oneshot waitctx;
         };
         static inline __outstanding_io *& Next( __outstanding_io * n ) { return (__outstanding_io *)Next( (Colable *)n ); }
+        // queue of operations that are outstanding
         struct __outstanding_io_queue {
+                // spinlock for protection
+                // TODO: changing to a lock that blocks, I haven't examined whether it should be a kernel or user lock
                 __spinlock_t lock;
+                // the actual queue
                 Queue(__outstanding_io) queue;
+                // volatile used to avoid the need for taking the lock if it's empty
                 volatile bool empty;
         };
+        // struct representing an operation that was submitted
         struct __external_io {
+                // inherits from outstanding io
                 inline __outstanding_io;
+                // pointer and count to an array of ids to be submitted
                 __u32 * idxs;
                 __u32 have;
+                // whether or not these can be accumulated before flushing the buffer
                 bool lazy;
         };
+        // complete io_context, contains all the data for io submission and completion
         struct __attribute__((aligned(64))) io_context$ {
+                // arbiter, used in cases where threads for migrated at unfortunate moments
                 io_arbiter$ * arbiter;
+                // which prcessor the context is tied to
                 struct processor * proc;
+                // queue of io submissions that haven't beeen processed.
                 __outstanding_io_queue ext_sq;
+                // io_uring ring data structures
                 struct __sub_ring_t sq;
                 struct __cmp_ring_t cq;
+                // flag the io_uring rings where created with
                 __u32 ring_flags;
+                // file descriptor that identifies the io_uring instance
                 int fd;
         };
+        // short hand to check when the io_context was last processed (io drained)
         static inline unsigned long long ts(io_context$ *& this) {
                 const __u32 head = *this->cq.head;
                 const __u32 tail = *this->cq.tail;
+                // if there is no pending completions, just pretend it's infinetely recent
                 if(head == tail) return ULLONG_MAX;
 …
+        }
+        // structure represeting allocations that couldn't succeed locally
         struct __pending_alloc {
+                // inherit from outstanding io
                 inline __outstanding_io;
+                // array and size of the desired allocation
                 __u32 * idxs;
                 __u32 want;
+                // output param, the context the io was allocated from
                 io_context$ * ctx;
         };
+        // arbiter that handles cases where the context tied to the local processor is unable to satisfy the io
         monitor __attribute__((aligned(64))) io_arbiter$ {
+                // contains a queue of io for pending allocations
                 __outstanding_io_queue pending;
         };

libcfa/src/concurrency/iofwd.hfa

-              r34b4268
+              r24d6572
 // Author           : Thierry Delisle
 // Created On       : Thu Apr 23 17:31:00 2020
 // Last Modified By :
 // Last Modified On :
 // Update Count     :
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Mon Mar 13 23:54:57 2023
+// Update Count     : 1
 //
 …
 #include <unistd.h>
+#include <sys/socket.h>
 extern "C" {
         #include <asm/types.h>
 …
 typedef __off64_t off64_t;
-struct cluster;
-struct io_context$;
-struct iovec;
-struct msghdr;
-struct sockaddr;
-struct statx;
 struct epoll_event;
-struct io_uring_sqe;
 //-----------------------------------------------------------------------
 …
 // synchronous calls
 #if defined(CFA_HAVE_PREADV2)
         extern ssize_t cfa_preadv2(int fd, const struct iovec *iov, int iovcnt, off_t offset, int flags, __u64 submit_flags);
+        extern ssize_t cfa_preadv2(int fd, const struct iovec * iov, int iovcnt, off_t offset, int flags, __u64 submit_flags);
 #endif
 #if defined(CFA_HAVE_PWRITEV2)
         extern ssize_t cfa_pwritev2(int fd, const struct iovec *iov, int iovcnt, off_t offset, int flags, __u64 submit_flags);
+        extern ssize_t cfa_pwritev2(int fd, const struct iovec * iov, int iovcnt, off_t offset, int flags, __u64 submit_flags);
 #endif
 extern int cfa_fsync(int fd, __u64 submit_flags);
 extern int cfa_epoll_ctl(int epfd, int op, int fd, struct epoll_event *event, __u64 submit_flags);
+extern int cfa_epoll_ctl(int epfd, int op, int fd, struct epoll_event * event, __u64 submit_flags);
 extern int cfa_sync_file_range(int fd, off64_t offset, off64_t nbytes, unsigned int flags, __u64 submit_flags);
 extern  ssize_t cfa_sendmsg(int sockfd, const struct msghdr *msg, int flags, __u64 submit_flags);
 extern ssize_t cfa_recvmsg(int sockfd, struct msghdr *msg, int flags, __u64 submit_flags);
 extern ssize_t cfa_send(int sockfd, const void *buf, size_t len, int flags, __u64 submit_flags);
 extern ssize_t cfa_recv(int sockfd, void *buf, size_t len, int flags, __u64 submit_flags);
 extern int cfa_accept4(int sockfd, struct sockaddr *addr, socklen_t *addrlen, int flags, __u64 submit_flags);
 extern int cfa_connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen, __u64 submit_flags);
+extern  ssize_t cfa_sendmsg(int sockfd, const struct msghdr * msg, int flags, __u64 submit_flags);
+extern ssize_t cfa_recvmsg(int sockfd, struct msghdr * msg, int flags, __u64 submit_flags);
+extern ssize_t cfa_send(int sockfd, const void * buf, size_t len, int flags, __u64 submit_flags);
+extern ssize_t cfa_recv(int sockfd, void * buf, size_t len, int flags, __u64 submit_flags);
+extern int cfa_accept4(int sockfd, __SOCKADDR_ARG addr, socklen_t * restrict addrlen, int flags, __u64 submit_flags);
+extern int cfa_connect(int sockfd, __CONST_SOCKADDR_ARG addr, socklen_t addrlen, __u64 submit_flags);
 extern int cfa_fallocate(int fd, int mode, off_t offset, off_t len, __u64 submit_flags);
 extern int cfa_posix_fadvise(int fd, off_t offset, off_t len, int advice, __u64 submit_flags);
 extern int cfa_madvise(void *addr, size_t length, int advice, __u64 submit_flags);
 extern int cfa_openat(int dirfd, const char *pathname, int flags, mode_t mode, __u64 submit_flags);
+extern int cfa_madvise(void * addr, size_t length, int advice, __u64 submit_flags);
+extern int cfa_openat(int dirfd, const char * pathname, int flags, mode_t mode, __u64 submit_flags);
 #if defined(CFA_HAVE_OPENAT2)
         extern int cfa_openat2(int dirfd, const char *pathname, struct open_how * how, size_t size, __u64 submit_flags);
+        extern int cfa_openat2(int dirfd, const char * pathname, struct open_how * how, size_t size, __u64 submit_flags);
 #endif
 extern int cfa_close(int fd, __u64 submit_flags);
 #if defined(CFA_HAVE_STATX)
         extern int cfa_statx(int dirfd, const char *pathname, int flags, unsigned int mask, struct statx *statxbuf, __u64 submit_flags);
+        extern int cfa_statx(int dirfd, const char * pathname, int flags, unsigned int mask, struct statx * statxbuf, __u64 submit_flags);
 #endif
 extern ssize_t cfa_read(int fd, void * buf, size_t count, __u64 submit_flags);
 extern ssize_t cfa_write(int fd, void * buf, size_t count, __u64 submit_flags);
 extern ssize_t cfa_splice(int fd_in, __off64_t *off_in, int fd_out, __off64_t *off_out, size_t len, unsigned int flags, __u64 submit_flags);
+extern ssize_t cfa_splice(int fd_in, __off64_t * off_in, int fd_out, __off64_t * off_out, size_t len, unsigned int flags, __u64 submit_flags);
 extern ssize_t cfa_tee(int fd_in, int fd_out, size_t len, unsigned int flags, __u64 submit_flags);
 …
 // asynchronous calls
 #if defined(CFA_HAVE_PREADV2)
         extern void async_preadv2(io_future_t & future, int fd, const struct iovec *iov, int iovcnt, off_t offset, int flags, __u64 submit_flags);
+        extern void async_preadv2(io_future_t & future, int fd, const struct iovec * iov, int iovcnt, off_t offset, int flags, __u64 submit_flags);
 #endif
 #if defined(CFA_HAVE_PWRITEV2)
         extern void async_pwritev2(io_future_t & future, int fd, const struct iovec *iov, int iovcnt, off_t offset, int flags, __u64 submit_flags);
+        extern void async_pwritev2(io_future_t & future, int fd, const struct iovec * iov, int iovcnt, off_t offset, int flags, __u64 submit_flags);
 #endif
 extern void async_fsync(io_future_t & future, int fd, __u64 submit_flags);
 extern void async_epoll_ctl(io_future_t & future, int epfd, int op, int fd, struct epoll_event *event, __u64 submit_flags);
+extern void async_epoll_ctl(io_future_t & future, int epfd, int op, int fd, struct epoll_event * event, __u64 submit_flags);
 extern void async_sync_file_range(io_future_t & future, int fd, off64_t offset, off64_t nbytes, unsigned int flags, __u64 submit_flags);
 extern void async_sendmsg(io_future_t & future, int sockfd, const struct msghdr *msg, int flags, __u64 submit_flags);
 extern void async_recvmsg(io_future_t & future, int sockfd, struct msghdr *msg, int flags, __u64 submit_flags);
 extern void async_send(io_future_t & future, int sockfd, const void *buf, size_t len, int flags, __u64 submit_flags);
 extern void async_recv(io_future_t & future, int sockfd, void *buf, size_t len, int flags, __u64 submit_flags);
 extern void async_accept4(io_future_t & future, int sockfd, struct sockaddr *addr, socklen_t *addrlen, int flags, __u64 submit_flags);
 extern void async_connect(io_future_t & future, int sockfd, const struct sockaddr *addr, socklen_t addrlen, __u64 submit_flags);
+extern void async_sendmsg(io_future_t & future, int sockfd, const struct msghdr * msg, int flags, __u64 submit_flags);
+extern void async_recvmsg(io_future_t & future, int sockfd, struct msghdr * msg, int flags, __u64 submit_flags);
+extern void async_send(io_future_t & future, int sockfd, const void * buf, size_t len, int flags, __u64 submit_flags);
+extern void async_recv(io_future_t & future, int sockfd, void * buf, size_t len, int flags, __u64 submit_flags);
+extern void async_accept4(io_future_t & future, int sockfd, __SOCKADDR_ARG addr, socklen_t * restrict addrlen, int flags, __u64 submit_flags);
+extern void async_connect(io_future_t & future, int sockfd, __CONST_SOCKADDR_ARG addr, socklen_t addrlen, __u64 submit_flags);
 extern void async_fallocate(io_future_t & future, int fd, int mode, off_t offset, off_t len, __u64 submit_flags);
 extern void async_posix_fadvise(io_future_t & future, int fd, off_t offset, off_t len, int advice, __u64 submit_flags);
 extern void async_madvise(io_future_t & future, void *addr, size_t length, int advice, __u64 submit_flags);
 extern void async_openat(io_future_t & future, int dirfd, const char *pathname, int flags, mode_t mode, __u64 submit_flags);
+extern void async_madvise(io_future_t & future, void * addr, size_t length, int advice, __u64 submit_flags);
+extern void async_openat(io_future_t & future, int dirfd, const char * pathname, int flags, mode_t mode, __u64 submit_flags);
 #if defined(CFA_HAVE_OPENAT2)
         extern void async_openat2(io_future_t & future, int dirfd, const char *pathname, struct open_how * how, size_t size, __u64 submit_flags);
+        extern void async_openat2(io_future_t & future, int dirfd, const char * pathname, struct open_how * how, size_t size, __u64 submit_flags);
 #endif
 extern void async_close(io_future_t & future, int fd, __u64 submit_flags);
 #if defined(CFA_HAVE_STATX)
         extern void async_statx(io_future_t & future, int dirfd, const char *pathname, int flags, unsigned int mask, struct statx *statxbuf, __u64 submit_flags);
+        extern void async_statx(io_future_t & future, int dirfd, const char * pathname, int flags, unsigned int mask, struct statx * statxbuf, __u64 submit_flags);
 #endif
 void async_read(io_future_t & future, int fd, void * buf, size_t count, __u64 submit_flags);
 extern void async_write(io_future_t & future, int fd, void * buf, size_t count, __u64 submit_flags);
 extern void async_splice(io_future_t & future, int fd_in, __off64_t *off_in, int fd_out, __off64_t *off_out, size_t len, unsigned int flags, __u64 submit_flags);
+extern void async_splice(io_future_t & future, int fd_in, __off64_t * off_in, int fd_out, __off64_t * off_out, size_t len, unsigned int flags, __u64 submit_flags);
 extern void async_tee(io_future_t & future, int fd_in, int fd_out, size_t len, unsigned int flags, __u64 submit_flags);

libcfa/src/concurrency/kernel.cfa

-              r34b4268
+              r24d6572
 // Created On       : Tue Jan 17 12:27:26 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed Nov 30 18:14:08 2022
 // Update Count     : 76
+// Last Modified On : Mon Jan  9 08:42:05 2023
+// Update Count     : 77
 //
 #define __cforall_thread__
-#define _GNU_SOURCE
 // #define __CFA_DEBUG_PRINT_RUNTIME_CORE__
 …
                 __cfadbg_print_safe(runtime_core, "Kernel : core %p stopping\n", this);
+        }
+        __cfa_io_flush( this );
+        __cfa_io_drain( this );
         post( this->terminated );

libcfa/src/concurrency/kernel/cluster.cfa

-              r34b4268
+              r24d6572
 #define __cforall_thread__
-#define _GNU_SOURCE
 #include "bits/defs.hfa"
 …
         return max_cores_l;
+}
-#if   defined(CFA_HAVE_LINUX_LIBRSEQ)
-        // No forward declaration needed
-        #define __kernel_rseq_register rseq_register_current_thread
-        #define __kernel_rseq_unregister rseq_unregister_current_thread
-#elif defined(CFA_HAVE_LINUX_RSEQ_H)
-        static void __kernel_raw_rseq_register  (void);
-        static void __kernel_raw_rseq_unregister(void);
-        #define __kernel_rseq_register __kernel_raw_rseq_register
-        #define __kernel_rseq_unregister __kernel_raw_rseq_unregister
-#else
-        // No forward declaration needed
-        // No initialization needed
-        static inline void noop(void) {}
-        #define __kernel_rseq_register noop
-        #define __kernel_rseq_unregister noop
-#endif
 //=======================================================================
 …
 // Lock-Free registering/unregistering of threads
 unsigned register_proc_id( void ) with(__scheduler_lock.lock) {
-        __kernel_rseq_register();
         bool * handle = (bool *)&kernelTLS().sched_lock;
 …
         __atomic_store_n(cell, 0p, __ATOMIC_RELEASE);
-        __kernel_rseq_unregister();
+}
 …
         /* paranoid */ verify( mock_head(this)    == this.l.prev );
+}
-#if   defined(CFA_HAVE_LINUX_LIBRSEQ)
-        // No definition needed
-#elif defined(CFA_HAVE_LINUX_RSEQ_H)
-        #if defined( __x86_64 ) || defined( __i386 )
-                #define RSEQ_SIG        0x53053053
-        #elif defined( __ARM_ARCH )
-                #ifdef __ARMEB__
-                #define RSEQ_SIG    0xf3def5e7      /* udf    #24035    ; 0x5de3 (ARMv6+) */
-                #else
-                #define RSEQ_SIG    0xe7f5def3      /* udf    #24035    ; 0x5de3 */
-                #endif
-        #endif
-        extern void __disable_interrupts_hard();
-        extern void __enable_interrupts_hard();
-        static void __kernel_raw_rseq_register  (void) {
-                /* paranoid */ verify( __cfaabi_rseq.cpu_id == RSEQ_CPU_ID_UNINITIALIZED );
-                // int ret = syscall(__NR_rseq, &__cfaabi_rseq, sizeof(struct rseq), 0, (sigset_t *)0p, _NSIG / 8);
-                int ret = syscall(__NR_rseq, &__cfaabi_rseq, sizeof(struct rseq), 0, RSEQ_SIG);
-                if(ret != 0) {
-                        int e = errno;
-                        switch(e) {
-                        case EINVAL: abort("KERNEL ERROR: rseq register invalid argument");
-                        case ENOSYS: abort("KERNEL ERROR: rseq register no supported");
-                        case EFAULT: abort("KERNEL ERROR: rseq register with invalid argument");
-                        case EBUSY : abort("KERNEL ERROR: rseq register already registered");
-                        case EPERM : abort("KERNEL ERROR: rseq register sig  argument  on unregistration does not match the signature received on registration");
-                        default: abort("KERNEL ERROR: rseq register unexpected return %d", e);
+                        }
+                }
+        }
-        static void __kernel_raw_rseq_unregister(void) {
-                /* paranoid */ verify( __cfaabi_rseq.cpu_id >= 0 );
-                // int ret = syscall(__NR_rseq, &__cfaabi_rseq, sizeof(struct rseq), RSEQ_FLAG_UNREGISTER, (sigset_t *)0p, _NSIG / 8);
-                int ret = syscall(__NR_rseq, &__cfaabi_rseq, sizeof(struct rseq), RSEQ_FLAG_UNREGISTER, RSEQ_SIG);
-                if(ret != 0) {
-                        int e = errno;
-                        switch(e) {
-                        case EINVAL: abort("KERNEL ERROR: rseq unregister invalid argument");
-                        case ENOSYS: abort("KERNEL ERROR: rseq unregister no supported");
-                        case EFAULT: abort("KERNEL ERROR: rseq unregister with invalid argument");
-                        case EBUSY : abort("KERNEL ERROR: rseq unregister already registered");
-                        case EPERM : abort("KERNEL ERROR: rseq unregister sig  argument  on unregistration does not match the signature received on registration");
-                        default: abort("KERNEL ERROR: rseq unregisteunexpected return %d", e);
+                        }
+                }
+        }
-#else
-        // No definition needed
-#endif

libcfa/src/concurrency/kernel/cluster.hfa

-              r34b4268
+              r24d6572
 // convert to log2 scale but using double
 static inline __readyQ_avg_t __to_readyQ_avg(unsigned long long intsc) { if(unlikely(0 == intsc)) return 0.0; else return log2(intsc); }
+static inline __readyQ_avg_t __to_readyQ_avg(unsigned long long intsc) { if(unlikely(0 == intsc)) return 0.0; else return log2((__readyQ_avg_t)intsc); }
 #define warn_large_before warnf( !strict || old_avg < 35.0, "Suspiciously large previous average: %'lf, %'" PRId64 "ms \n", old_avg, program()`ms )
 …
+}
 static struct {
         const unsigned readyq;
         const unsigned io;
+const static struct {
+        unsigned readyq;
+        unsigned io;
 } __shard_factor = { 2, 1 };

libcfa/src/concurrency/kernel/private.hfa

-              r34b4268
+              r24d6572
 // Created On       : Mon Feb 13 12:27:26 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed Aug 12 08:21:33 2020
 // Update Count     : 9
+// Last Modified On : Thu Mar  2 16:04:46 2023
+// Update Count     : 11
 //
 …
 extern "C" {
-#if   defined(CFA_HAVE_LINUX_LIBRSEQ)
-        #include <rseq/rseq.h>
-#elif defined(CFA_HAVE_LINUX_RSEQ_H)
-        #include <linux/rseq.h>
-#else
-        #ifndef _GNU_SOURCE
-        #error kernel/private requires gnu_source
-        #endif
         #include <sched.h>
-#endif
+}
 …
 // Hardware
-#if   defined(CFA_HAVE_LINUX_LIBRSEQ)
-        // No data needed
-#elif defined(CFA_HAVE_LINUX_RSEQ_H)
-        extern "Cforall" {
-                extern __attribute__((aligned(64))) __thread volatile struct rseq __cfaabi_rseq;
+        }
-#else
-        // No data needed
-#endif
 static inline int __kernel_getcpu() {
         /* paranoid */ verify( ! __preemption_enabled() );
-#if   defined(CFA_HAVE_LINUX_LIBRSEQ)
-        return rseq_current_cpu();
-#elif defined(CFA_HAVE_LINUX_RSEQ_H)
-        int r = __cfaabi_rseq.cpu_id;
-        /* paranoid */ verify( r >= 0 );
-        return r;
-#else
         return sched_getcpu();
-#endif
+}

libcfa/src/concurrency/kernel/startup.cfa

-              r34b4268
+              r24d6572
 #define __cforall_thread__
-#define _GNU_SOURCE
 // #define __CFA_DEBUG_PRINT_RUNTIME_CORE__
 // C Includes
 #include <errno.h>                                      // errno
+#include <errno.h>                                                                              // errno
 #include <signal.h>
 #include <string.h>                                     // strerror
 #include <unistd.h>                                     // sysconf
+#include <string.h>                                                                             // strerror
+#include <unistd.h>
+#include <limits.h>                                                                             // PTHREAD_STACK_MIN
 extern "C" {
+        #include <limits.h>                             // PTHREAD_STACK_MIN
+        #include <unistd.h>                             // syscall
+        #include <sys/eventfd.h>                        // eventfd
+        #include <sys/mman.h>                           // mprotect
+        #include <sys/resource.h>                       // getrlimit
+        #include <sys/eventfd.h>                                                        // eventfd
+        #include <sys/mman.h>                                                           // mprotect
+        #include <sys/resource.h>                                                       // getrlimit
+}
 …
 #include "kernel/private.hfa"
 #include "iofwd.hfa"
 #include "startup.hfa"                                  // STARTUP_PRIORITY_XXX
+#include "startup.hfa"                                                                  // STARTUP_PRIORITY_XXX
 #include "limits.hfa"
 #include "math.hfa"
 …
 __scheduler_RWLock_t __scheduler_lock @= { 0 };
-#if   defined(CFA_HAVE_LINUX_LIBRSEQ)
-        // No data needed
-#elif defined(CFA_HAVE_LINUX_RSEQ_H)
-        extern "Cforall" {
-                __attribute__((aligned(64))) __thread volatile struct rseq __cfaabi_rseq @= {
-                        .cpu_id : RSEQ_CPU_ID_UNINITIALIZED,
-                };
+        }
-#else
-        // No data needed
-#endif
 //-----------------------------------------------------------------------------
 // Struct to steal stack

libcfa/src/concurrency/locks.cfa

-              r34b4268
+              r24d6572
 // file "LICENCE" distributed with Cforall.
 //
 // locks.hfa -- LIBCFATHREAD
+// locks.cfa -- LIBCFATHREAD
 // Runtime locks that used with the runtime thread system.
 //
 …
 #define __cforall_thread__
-#define _GNU_SOURCE
 #include "locks.hfa"
 …
         // lock is held by some other thread
         if ( owner != 0p && owner != thrd ) {
+                insert_last( blocked_threads, *thrd );
+        select_node node;
+                insert_last( blocked_threads, node );
                 wait_count++;
                 unlock( lock );
                 park( );
+        }
+        // multi acquisition lock is held by current thread
+        else if ( owner == thrd && multi_acquisition ) {
+        return;
+        } else if ( owner == thrd && multi_acquisition ) { // multi acquisition lock is held by current thread
                 recursion_count++;
+                unlock( lock );
+        }
+        // lock isn't held
+        else {
+        } else {  // lock isn't held
                 owner = thrd;
                 recursion_count = 1;
                 unlock( lock );
+        }
+        }
+    unlock( lock );
+}
 …
+}
+static void pop_and_set_new_owner( blocking_lock & this ) with( this ) {
+        thread$ * t = &try_pop_front( blocked_threads );
+        owner = t;
+        recursion_count = ( t ? 1 : 0 );
+        if ( t ) wait_count--;
+        unpark( t );
+static inline void pop_node( blocking_lock & this ) with( this ) {
+    __handle_waituntil_OR( blocked_threads );
+    select_node * node = &try_pop_front( blocked_threads );
+    if ( node ) {
+        wait_count--;
+        owner = node->blocked_thread;
+        recursion_count = 1;
+        // if ( !node->clause_status || __make_select_node_available( *node ) ) unpark( node->blocked_thread );
+        wake_one( blocked_threads, *node );
+    } else {
+        owner = 0p;
+        recursion_count = 0;
+    }
+}
 …
         recursion_count--;
         if ( recursion_count == 0 ) {
                 pop_and_set_new_owner( this );
+                pop_node( this );
+        }
         unlock( lock );
 …
         // lock held
         if ( owner != 0p ) {
                 insert_last( blocked_threads, *t );
+                insert_last( blocked_threads, *(select_node *)t->link_node );
                 wait_count++;
-                unlock( lock );
+        }
         // lock not held
 …
                 recursion_count = 1;
                 unpark( t );
                 unlock( lock );
+        }
+}
 size_t on_wait( blocking_lock & this ) with( this ) {
+        }
+    unlock( lock );
+}
+size_t on_wait( blocking_lock & this, __cfa_pre_park pp_fn, void * pp_datum ) with( this ) {
         lock( lock __cfaabi_dbg_ctx2 );
         /* paranoid */ verifyf( owner != 0p, "Attempt to release lock %p that isn't held", &this );
 …
         size_t ret = recursion_count;
+        pop_and_set_new_owner( this );
+        pop_node( this );
+    select_node node;
+    active_thread()->link_node = (void *)&node;
         unlock( lock );
+    pre_park_then_park( pp_fn, pp_datum );
         return ret;
+}
 …
         recursion_count = recursion;
+}
+// waituntil() support
+bool register_select( blocking_lock & this, select_node & node ) with(this) {
+    lock( lock __cfaabi_dbg_ctx2 );
+        thread$ * thrd = active_thread();
+        // single acquisition lock is held by current thread
+        /* paranoid */ verifyf( owner != thrd || multi_acquisition, "Single acquisition lock holder (%p) attempted to reacquire the lock %p resulting in a deadlock.", owner, &this );
+    if ( !node.park_counter && ( (owner == thrd && multi_acquisition) || owner == 0p ) ) { // OR special case
+        if ( !__make_select_node_available( node ) ) { // we didn't win the race so give up on registering
+           unlock( lock );
+           return false;
+        }
+    }
+        // lock is held by some other thread
+        if ( owner != 0p && owner != thrd ) {
+                insert_last( blocked_threads, node );
+                wait_count++;
+                unlock( lock );
+        return false;
+        } else if ( owner == thrd && multi_acquisition ) { // multi acquisition lock is held by current thread
+                recursion_count++;
+        } else {  // lock isn't held
+                owner = thrd;
+                recursion_count = 1;
+        }
+    if ( node.park_counter ) __make_select_node_available( node );
+    unlock( lock );
+    return true;
+}
+bool unregister_select( blocking_lock & this, select_node & node ) with(this) {
+    lock( lock __cfaabi_dbg_ctx2 );
+    if ( node`isListed ) {
+        remove( node );
+        wait_count--;
+        unlock( lock );
+        return false;
+    }
+    if ( owner == active_thread() ) {
+        /* paranoid */ verifyf( recursion_count == 1 || multi_acquisition, "Thread %p attempted to unlock owner lock %p in waituntil unregister, which is not recursive but has a recursive count of %zu", active_thread(), &this, recursion_count );
+        // if recursion count is zero release lock and set new owner if one is waiting
+        recursion_count--;
+        if ( recursion_count == 0 ) {
+            pop_node( this );
+        }
+    }
+        unlock( lock );
+    return false;
+}
+void on_selected( blocking_lock & this, select_node & node ) {}
 //-----------------------------------------------------------------------------
 …
         int counter( condition_variable(L) & this ) with(this) { return count; }
         static size_t queue_and_get_recursion( condition_variable(L) & this, info_thread(L) * i ) with(this) {
+        static void enqueue_thread( condition_variable(L) & this, info_thread(L) * i ) with(this) {
                 // add info_thread to waiting queue
                 insert_last( blocked_threads, *i );
                 count++;
+                size_t recursion_count = 0;
+                if (i->lock) {
+                        // if lock was passed get recursion count to reset to after waking thread
+                        recursion_count = on_wait( *i->lock );
+                }
+                return recursion_count;
+        }
+        }
+    static size_t block_and_get_recursion( info_thread(L) & i, __cfa_pre_park pp_fn, void * pp_datum ) {
+        size_t recursion_count = 0;
+                if ( i.lock ) // if lock was passed get recursion count to reset to after waking thread
+                        recursion_count = on_wait( *i.lock, pp_fn, pp_datum ); // this call blocks
+                else
+            pre_park_then_park( pp_fn, pp_datum );
+        return recursion_count;
+    }
+    static size_t block_and_get_recursion( info_thread(L) & i ) { return block_and_get_recursion( i, pre_park_noop, 0p ); }
         // helper for wait()'s' with no timeout
         static void queue_info_thread( condition_variable(L) & this, info_thread(L) & i ) with(this) {
                 lock( lock __cfaabi_dbg_ctx2 );
                 size_t recursion_count = queue_and_get_recursion(this, &i);
+        enqueue_thread( this, &i );
                 unlock( lock );
                 // blocks here
                 park( );
+        size_t recursion_count = block_and_get_recursion( i );
                 // resets recursion count here after waking
                 if (i.lock) on_wakeup(*i.lock, recursion_count);
+                if ( i.lock ) on_wakeup( *i.lock, recursion_count );
+        }
 …
                 queue_info_thread( this, i );
+    static void cond_alarm_register( void * node_ptr ) { register_self( (alarm_node_t *)node_ptr ); }
         // helper for wait()'s' with a timeout
         static void queue_info_thread_timeout( condition_variable(L) & this, info_thread(L) & info, Duration t, Alarm_Callback callback ) with(this) {
                 lock( lock __cfaabi_dbg_ctx2 );
                 size_t recursion_count = queue_and_get_recursion(this, &info);
+        enqueue_thread( this, &info );
                 alarm_node_wrap(L) node_wrap = { t, 0`s, callback, &this, &info };
                 unlock( lock );
+                // registers alarm outside cond lock to avoid deadlock
+                register_self( &node_wrap.alarm_node );
+                // blocks here
+                park();
+                // blocks here and registers alarm node before blocking after releasing locks to avoid deadlock
+        size_t recursion_count = block_and_get_recursion( info, cond_alarm_register, (void *)(&node_wrap.alarm_node) );
+                // park();
                 // unregisters alarm so it doesn't go off if this happens first
 …
                 // resets recursion count here after waking
                 if (info.lock) on_wakeup(*info.lock, recursion_count);
+                if ( info.lock ) on_wakeup( *info.lock, recursion_count );
+        }
 …
                 info_thread( L ) i = { active_thread(), info, &l };
                 insert_last( blocked_threads, i );
                 size_t recursion_count = on_wait( *i.lock );
                 park( );
+                size_t recursion_count = on_wait( *i.lock, pre_park_noop, 0p ); // blocks here
+                // park( );
                 on_wakeup(*i.lock, recursion_count);
+        }
 …
         bool empty ( pthread_cond_var(L) & this ) with(this) { return blocked_threads`isEmpty; }
-        static size_t queue_and_get_recursion( pthread_cond_var(L) & this, info_thread(L) * i ) with(this) {
-                // add info_thread to waiting queue
-                insert_last( blocked_threads, *i );
-                size_t recursion_count = 0;
-                recursion_count = on_wait( *i->lock );
-                return recursion_count;
+        }
         static void queue_info_thread_timeout( pthread_cond_var(L) & this, info_thread(L) & info, Duration t, Alarm_Callback callback ) with(this) {
                 lock( lock __cfaabi_dbg_ctx2 );
                 size_t recursion_count = queue_and_get_recursion(this, &info);
+        insert_last( blocked_threads, info );
                 pthread_alarm_node_wrap(L) node_wrap = { t, 0`s, callback, &this, &info };
                 unlock( lock );
+                // registers alarm outside cond lock to avoid deadlock
+                register_self( &node_wrap.alarm_node );
+                // blocks here
+                park();
+                // unregisters alarm so it doesn't go off if this happens first
+                // blocks here and registers alarm node before blocking after releasing locks to avoid deadlock
+        size_t recursion_count = block_and_get_recursion( info, cond_alarm_register, (void *)(&node_wrap.alarm_node) );
+                // unregisters alarm so it doesn't go off if signal happens first
                 unregister_self( &node_wrap.alarm_node );
                 // resets recursion count here after waking
                 if (info.lock) on_wakeup(*info.lock, recursion_count);
+                if ( info.lock ) on_wakeup( *info.lock, recursion_count );
+        }
 …
                 lock( lock __cfaabi_dbg_ctx2 );
                 info_thread( L ) i = { active_thread(), info, &l };
+                size_t recursion_count = queue_and_get_recursion(this, &i);
+                unlock( lock );
+                park( );
+                on_wakeup(*i.lock, recursion_count);
+        insert_last( blocked_threads, i );
+                unlock( lock );
+        // blocks here
+                size_t recursion_count = block_and_get_recursion( i );
+                on_wakeup( *i.lock, recursion_count );
+        }
 …
         return thrd != 0p;
+}

libcfa/src/concurrency/locks.hfa

-              r34b4268
+              r24d6572
 #include "time.hfa"
+#include "select.hfa"
 #include <fstream.hfa>
 // futex headers
 …
 #include <unistd.h>
+// undef to make a number of the locks not reacquire upon waking from a condlock
+#define REACQ 1
+typedef void (*__cfa_pre_park)( void * );
+static inline void pre_park_noop( void * ) {}
+//-----------------------------------------------------------------------------
+// is_blocking_lock
+forall( L & | sized(L) )
+trait is_blocking_lock {
+        // For synchronization locks to use when acquiring
+        void on_notify( L &, struct thread$ * );
+        // For synchronization locks to use when releasing
+        size_t on_wait( L &, __cfa_pre_park pp_fn, void * pp_datum );
+        // to set recursion count after getting signalled;
+        void on_wakeup( L &, size_t recursion );
+};
+static inline void pre_park_then_park( __cfa_pre_park pp_fn, void * pp_datum ) {
+    pp_fn( pp_datum );
+    park();
+}
+// macros for default routine impls for is_blocking_lock trait that do not wait-morph
+#define DEFAULT_ON_NOTIFY( lock_type ) \
+    static inline void on_notify( lock_type & this, thread$ * t ){ unpark(t); }
+#define DEFAULT_ON_WAIT( lock_type ) \
+    static inline size_t on_wait( lock_type & this, __cfa_pre_park pp_fn, void * pp_datum ) { \
+        unlock( this ); \
+        pre_park_then_park( pp_fn, pp_datum ); \
+        return 0; \
+    }
+// on_wakeup impl if lock should be reacquired after waking up
+#define DEFAULT_ON_WAKEUP_REACQ( lock_type ) \
+    static inline void on_wakeup( lock_type & this, size_t recursion ) { lock( this ); }
+// on_wakeup impl if lock will not be reacquired after waking up
+#define DEFAULT_ON_WAKEUP_NO_REACQ( lock_type ) \
+    static inline void on_wakeup( lock_type & this, size_t recursion ) {}
 //-----------------------------------------------------------------------------
 …
 static inline bool   try_lock ( single_acquisition_lock & this ) { return try_lock( (blocking_lock &)this ); }
 static inline void   unlock   ( single_acquisition_lock & this ) { unlock  ( (blocking_lock &)this ); }
 static inline size_t on_wait  ( single_acquisition_lock & this ) { return on_wait ( (blocking_lock &)this ); }
+static inline size_t on_wait  ( single_acquisition_lock & this, __cfa_pre_park pp_fn, void * pp_datum ) { return on_wait ( (blocking_lock &)this, pp_fn, pp_datum ); }
 static inline void   on_wakeup( single_acquisition_lock & this, size_t v ) { on_wakeup ( (blocking_lock &)this, v ); }
 static inline void   on_notify( single_acquisition_lock & this, struct thread$ * t ) { on_notify( (blocking_lock &)this, t ); }
+static inline bool   register_select( single_acquisition_lock & this, select_node & node ) { return register_select( (blocking_lock &)this, node ); }
+static inline bool   unregister_select( single_acquisition_lock & this, select_node & node ) { return unregister_select( (blocking_lock &)this, node ); }
+static inline void   on_selected( single_acquisition_lock & this, select_node & node ) { on_selected( (blocking_lock &)this, node ); }
 //----------
 …
 static inline bool   try_lock ( owner_lock & this ) { return try_lock( (blocking_lock &)this ); }
 static inline void   unlock   ( owner_lock & this ) { unlock  ( (blocking_lock &)this ); }
 static inline size_t on_wait  ( owner_lock & this ) { return on_wait ( (blocking_lock &)this ); }
+static inline size_t on_wait  ( owner_lock & this, __cfa_pre_park pp_fn, void * pp_datum ) { return on_wait ( (blocking_lock &)this, pp_fn, pp_datum ); }
 static inline void   on_wakeup( owner_lock & this, size_t v ) { on_wakeup ( (blocking_lock &)this, v ); }
 static inline void   on_notify( owner_lock & this, struct thread$ * t ) { on_notify( (blocking_lock &)this, t ); }
+static inline bool   register_select( owner_lock & this, select_node & node ) { return register_select( (blocking_lock &)this, node ); }
+static inline bool   unregister_select( owner_lock & this, select_node & node ) { return unregister_select( (blocking_lock &)this, node ); }
+static inline void   on_selected( owner_lock & this, select_node & node ) { on_selected( (blocking_lock &)this, node ); }
 //-----------------------------------------------------------------------------
 …
 static inline void ?{}(mcs_spin_node & this) { this.next = 0p; this.locked = true; }
-static inline mcs_spin_node * volatile & ?`next ( mcs_spin_node * node ) {
-        return node->next;
+}
 struct mcs_spin_lock {
         mcs_spin_queue queue;
 …
 static inline void lock(mcs_spin_lock & l, mcs_spin_node & n) {
+    n.locked = true;
         mcs_spin_node * prev = __atomic_exchange_n(&l.queue.tail, &n, __ATOMIC_SEQ_CST);
+        n.locked = true;
+        if(prev == 0p) return;
+        if( prev == 0p ) return;
         prev->next = &n;
         while(__atomic_load_n(&n.locked, __ATOMIC_RELAXED)) Pause();
+        while( __atomic_load_n(&n.locked, __ATOMIC_RELAXED) ) Pause();
+}
 …
         mcs_spin_node * n_ptr = &n;
         if (__atomic_compare_exchange_n(&l.queue.tail, &n_ptr, 0p, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST)) return;
         while (__atomic_load_n(&n.next, __ATOMIC_RELAXED) == 0p) {}
+        while (__atomic_load_n(&n.next, __ATOMIC_RELAXED) == 0p) Pause();
         n.next->locked = false;
+}
 …
 // futex_mutex
-// - No cond var support
 // - Kernel thd blocking alternative to the spinlock
 // - No ownership (will deadlock on reacq)
+// - no reacq on wakeup
 struct futex_mutex {
         // lock state any state other than UNLOCKED is locked
 …
+}
 static inline void  ?{}( futex_mutex & this ) with(this) { val = 0; }
 static inline bool internal_try_lock(futex_mutex & this, int & compare_val) with(this) {
+static inline void ?{}( futex_mutex & this ) with(this) { val = 0; }
+static inline bool internal_try_lock( futex_mutex & this, int & compare_val) with(this) {
         return __atomic_compare_exchange_n((int*)&val, (int*)&compare_val, 1, false, __ATOMIC_ACQUIRE, __ATOMIC_ACQUIRE);
+}
 static inline int internal_exchange(futex_mutex & this) with(this) {
+static inline int internal_exchange( futex_mutex & this ) with(this) {
         return __atomic_exchange_n((int*)&val, 2, __ATOMIC_ACQUIRE);
+}
 // if this is called recursively IT WILL DEADLOCK!!!!!
 static inline void lock(futex_mutex & this) with(this) {
+static inline void lock( futex_mutex & this ) with(this) {
         int state;
+        // // linear backoff omitted for now
+        // for( int spin = 4; spin < 1024; spin += spin) {
+        //      state = 0;
+        //      // if unlocked, lock and return
+        //      if (internal_try_lock(this, state)) return;
+        //      if (2 == state) break;
+        //      for (int i = 0; i < spin; i++) Pause();
+        // }
+        // no contention try to acquire
+        if (internal_try_lock(this, state)) return;
+        for( int spin = 4; spin < 1024; spin += spin) {
+                state = 0;
+                // if unlocked, lock and return
+                if (internal_try_lock(this, state)) return;
+                if (2 == state) break;
+                for (int i = 0; i < spin; i++) Pause();
+        }
         // if not in contended state, set to be in contended state
 …
 static inline void unlock(futex_mutex & this) with(this) {
         // if uncontended do atomice unlock and then return
+        if (__atomic_fetch_sub(&val, 1, __ATOMIC_RELEASE) == 1) return; // TODO: try acq/rel
+        // if uncontended do atomic unlock and then return
+    if (__atomic_exchange_n(&val, 0, __ATOMIC_RELEASE) == 1) return;
         // otherwise threads are blocked so we must wake one
-        __atomic_store_n((int *)&val, 0, __ATOMIC_RELEASE);
         futex((int *)&val, FUTEX_WAKE, 1);
+}
+static inline void on_notify( futex_mutex & f, thread$ * t){ unpark(t); }
+static inline size_t on_wait( futex_mutex & f ) {unlock(f); return 0;}
+// to set recursion count after getting signalled;
+static inline void on_wakeup( futex_mutex & f, size_t recursion ) {}
+//-----------------------------------------------------------------------------
+// CLH Spinlock
+// - No recursive acquisition
+// - Needs to be released by owner
+struct clh_lock {
+        volatile bool * volatile tail;
+};
+static inline void  ?{}( clh_lock & this ) { this.tail = malloc(); *this.tail = true; }
+static inline void ^?{}( clh_lock & this ) { free(this.tail); }
+static inline void lock(clh_lock & l) {
+        thread$ * curr_thd = active_thread();
+        *(curr_thd->clh_node) = false;
+        volatile bool * prev = __atomic_exchange_n((bool **)(&l.tail), (bool *)(curr_thd->clh_node), __ATOMIC_SEQ_CST);
+        while(!__atomic_load_n(prev, __ATOMIC_ACQUIRE)) Pause();
+        curr_thd->clh_prev = prev;
+}
+static inline void unlock(clh_lock & l) {
+        thread$ * curr_thd = active_thread();
+        __atomic_store_n(curr_thd->clh_node, true, __ATOMIC_RELEASE);
+        curr_thd->clh_node = curr_thd->clh_prev;
+}
+static inline void on_notify(clh_lock & this, struct thread$ * t ) { unpark(t); }
+static inline size_t on_wait(clh_lock & this) { unlock(this); return 0; }
+static inline void on_wakeup(clh_lock & this, size_t recursion ) {
+        #ifdef REACQ
+        lock(this);
+        #endif
+}
+//-----------------------------------------------------------------------------
+// Linear backoff Spinlock
+struct linear_backoff_then_block_lock {
+DEFAULT_ON_NOTIFY( futex_mutex )
+DEFAULT_ON_WAIT( futex_mutex )
+DEFAULT_ON_WAKEUP_NO_REACQ( futex_mutex )
+//-----------------------------------------------------------------------------
+// go_mutex
+// - Kernel thd blocking alternative to the spinlock
+// - No ownership (will deadlock on reacq)
+// - Golang's flavour of mutex
+// - Impl taken from Golang: src/runtime/lock_futex.go
+struct go_mutex {
+        // lock state any state other than UNLOCKED is locked
+        // enum LockState { UNLOCKED = 0, LOCKED = 1, SLEEPING = 2 };
+        // stores a lock state
+        int val;
+};
+static inline void  ?{}( go_mutex & this ) with(this) { val = 0; }
+// static inline void ?{}( go_mutex & this, go_mutex this2 ) = void; // these don't compile correctly at the moment so they should be omitted
+// static inline void ?=?( go_mutex & this, go_mutex this2 ) = void;
+static inline bool internal_try_lock(go_mutex & this, int & compare_val, int new_val ) with(this) {
+        return __atomic_compare_exchange_n((int*)&val, (int*)&compare_val, new_val, false, __ATOMIC_ACQUIRE, __ATOMIC_ACQUIRE);
+}
+static inline int internal_exchange(go_mutex & this, int swap ) with(this) {
+        return __atomic_exchange_n((int*)&val, swap, __ATOMIC_ACQUIRE);
+}
+// if this is called recursively IT WILL DEADLOCK!!!!!
+static inline void lock( go_mutex & this ) with( this ) {
+        int state, init_state;
+    // speculative grab
+    state = internal_exchange(this, 1);
+    if ( !state ) return; // state == 0
+    init_state = state;
+    for (;;) {
+        for( int i = 0; i < 4; i++ ) {
+            while( !val ) { // lock unlocked
+                state = 0;
+                if ( internal_try_lock( this, state, init_state ) ) return;
+            }
+            for (int i = 0; i < 30; i++) Pause();
+        }
+        while( !val ) { // lock unlocked
+            state = 0;
+            if ( internal_try_lock( this, state, init_state ) ) return;
+        }
+        sched_yield();
+        // if not in contended state, set to be in contended state
+        state = internal_exchange( this, 2 );
+        if ( !state ) return; // state == 0
+        init_state = 2;
+        futex( (int*)&val, FUTEX_WAIT, 2 ); // if val is not 2 this returns with EWOULDBLOCK
+    }
+}
+static inline void unlock( go_mutex & this ) with(this) {
+        // if uncontended do atomic unlock and then return
+    if ( __atomic_exchange_n(&val, 0, __ATOMIC_RELEASE) == 1 ) return;
+        // otherwise threads are blocked so we must wake one
+        futex( (int *)&val, FUTEX_WAKE, 1 );
+}
+DEFAULT_ON_NOTIFY( go_mutex )
+DEFAULT_ON_WAIT( go_mutex )
+DEFAULT_ON_WAKEUP_NO_REACQ( go_mutex )
+//-----------------------------------------------------------------------------
+// Exponential backoff then block lock
+struct exp_backoff_then_block_lock {
         // Spin lock used for mutual exclusion
         __spinlock_t spinlock;
 …
 };
 static inline void  ?{}( linear_backoff_then_block_lock & this ) {
+static inline void  ?{}( exp_backoff_then_block_lock & this ) {
         this.spinlock{};
         this.blocked_threads{};
         this.lock_value = 0;
+}
+static inline void ^?{}( linear_backoff_then_block_lock & this ) {}
+// static inline void ?{}( linear_backoff_then_block_lock & this, linear_backoff_then_block_lock this2 ) = void;
+// static inline void ?=?( linear_backoff_then_block_lock & this, linear_backoff_then_block_lock this2 ) = void;
+static inline bool internal_try_lock(linear_backoff_then_block_lock & this, size_t & compare_val) with(this) {
+        if (__atomic_compare_exchange_n(&lock_value, &compare_val, 1, false, __ATOMIC_ACQUIRE, __ATOMIC_RELAXED)) {
+                return true;
+        }
+        return false;
+}
+static inline bool try_lock(linear_backoff_then_block_lock & this) { size_t compare_val = 0; return internal_try_lock(this, compare_val); }
+static inline bool try_lock_contention(linear_backoff_then_block_lock & this) with(this) {
+        if (__atomic_exchange_n(&lock_value, 2, __ATOMIC_ACQUIRE) == 0) {
+                return true;
+        }
+        return false;
+}
+static inline bool block(linear_backoff_then_block_lock & this) with(this) {
+        lock( spinlock __cfaabi_dbg_ctx2 ); // TODO change to lockfree queue (MPSC)
+        if (lock_value != 2) {
+                unlock( spinlock );
+                return true;
+        }
+        insert_last( blocked_threads, *active_thread() );
+        unlock( spinlock );
+static inline void ?{}( exp_backoff_then_block_lock & this, exp_backoff_then_block_lock this2 ) = void;
+static inline void ?=?( exp_backoff_then_block_lock & this, exp_backoff_then_block_lock this2 ) = void;
+static inline void  ^?{}( exp_backoff_then_block_lock & this ){}
+static inline bool internal_try_lock( exp_backoff_then_block_lock & this, size_t & compare_val ) with(this) {
+        return __atomic_compare_exchange_n(&lock_value, &compare_val, 1, false, __ATOMIC_ACQUIRE, __ATOMIC_RELAXED);
+}
+static inline bool try_lock( exp_backoff_then_block_lock & this ) { size_t compare_val = 0; return internal_try_lock( this, compare_val ); }
+static inline bool try_lock_contention( exp_backoff_then_block_lock & this ) with(this) {
+        return !__atomic_exchange_n( &lock_value, 2, __ATOMIC_ACQUIRE );
+}
+static inline bool block( exp_backoff_then_block_lock & this ) with(this) {
+    lock( spinlock __cfaabi_dbg_ctx2 );
+    if (__atomic_load_n( &lock_value, __ATOMIC_SEQ_CST) != 2) {
+        unlock( spinlock );
+        return true;
+    }
+    insert_last( blocked_threads, *active_thread() );
+    unlock( spinlock );
         park( );
         return true;
+}
 static inline void lock(linear_backoff_then_block_lock & this) with(this) {
+static inline void lock( exp_backoff_then_block_lock & this ) with(this) {
         size_t compare_val = 0;
         int spin = 4;
         // linear backoff
         for( ;; ) {
 …
+}
 static inline void unlock(linear_backoff_then_block_lock & this) with(this) {
+static inline void unlock( exp_backoff_then_block_lock & this ) with(this) {
     if (__atomic_exchange_n(&lock_value, 0, __ATOMIC_RELEASE) == 1) return;
+        lock( spinlock __cfaabi_dbg_ctx2 );
+        thread$ * t = &try_pop_front( blocked_threads );
+        unlock( spinlock );
+        unpark( t );
+}
+static inline void on_notify(linear_backoff_then_block_lock & this, struct thread$ * t ) { unpark(t); }
+static inline size_t on_wait(linear_backoff_then_block_lock & this) { unlock(this); return 0; }
+static inline void on_wakeup(linear_backoff_then_block_lock & this, size_t recursion ) {
+        #ifdef REACQ
+        lock(this);
+        #endif
+}
+    lock( spinlock __cfaabi_dbg_ctx2 );
+    thread$ * t = &try_pop_front( blocked_threads );
+    unlock( spinlock );
+    unpark( t );
+}
+DEFAULT_ON_NOTIFY( exp_backoff_then_block_lock )
+DEFAULT_ON_WAIT( exp_backoff_then_block_lock )
+DEFAULT_ON_WAKEUP_REACQ( exp_backoff_then_block_lock )
 //-----------------------------------------------------------------------------
 …
 // if this is called recursively IT WILL DEADLOCK!!!!!
 static inline void lock(fast_block_lock & this) with(this) {
+static inline void lock( fast_block_lock & this ) with(this) {
         lock( lock __cfaabi_dbg_ctx2 );
         if ( held ) {
 …
+}
 static inline void unlock(fast_block_lock & this) with(this) {
+static inline void unlock( fast_block_lock & this ) with(this) {
         lock( lock __cfaabi_dbg_ctx2 );
         /* paranoid */ verifyf( held != false, "Attempt to release lock %p that isn't held", &this );
 …
+}
+static inline void on_notify(fast_block_lock & this, struct thread$ * t ) with(this) {
+        #ifdef REACQ
+                lock( lock __cfaabi_dbg_ctx2 );
+                insert_last( blocked_threads, *t );
+                unlock( lock );
+        #else
+                unpark(t);
+        #endif
+}
+static inline size_t on_wait(fast_block_lock & this) { unlock(this); return 0; }
+static inline void on_wakeup(fast_block_lock & this, size_t recursion ) { }
+static inline void on_notify( fast_block_lock & this, struct thread$ * t ) with(this) {
+    lock( lock __cfaabi_dbg_ctx2 );
+    insert_last( blocked_threads, *t );
+    unlock( lock );
+}
+DEFAULT_ON_WAIT( fast_block_lock )
+DEFAULT_ON_WAKEUP_NO_REACQ( fast_block_lock )
 //-----------------------------------------------------------------------------
 …
 struct simple_owner_lock {
         // List of blocked threads
         dlist( thread$ ) blocked_threads;
+        dlist( select_node ) blocked_threads;
         // Spin lock used for mutual exclusion
 …
 static inline void ?=?( simple_owner_lock & this, simple_owner_lock this2 ) = void;
 static inline void lock(simple_owner_lock & this) with(this) {
         if (owner == active_thread()) {
+static inline void lock( simple_owner_lock & this ) with(this) {
+        if ( owner == active_thread() ) {
                 recursion_count++;
                 return;
 …
         lock( lock __cfaabi_dbg_ctx2 );
+        if (owner != 0p) {
+                insert_last( blocked_threads, *active_thread() );
+        if ( owner != 0p ) {
+        select_node node;
+                insert_last( blocked_threads, node );
                 unlock( lock );
                 park( );
 …
+}
+// TODO: fix duplicate def issue and bring this back
+// void pop_and_set_new_owner( simple_owner_lock & this ) with( this ) {
+        // thread$ * t = &try_pop_front( blocked_threads );
+        // owner = t;
+        // recursion_count = ( t ? 1 : 0 );
+        // unpark( t );
+// }
+static inline void unlock(simple_owner_lock & this) with(this) {
+static inline void pop_node( simple_owner_lock & this ) with(this) {
+    __handle_waituntil_OR( blocked_threads );
+    select_node * node = &try_pop_front( blocked_threads );
+    if ( node ) {
+        owner = node->blocked_thread;
+        recursion_count = 1;
+        // if ( !node->clause_status || __make_select_node_available( *node ) ) unpark( node->blocked_thread );
+        wake_one( blocked_threads, *node );
+    } else {
+        owner = 0p;
+        recursion_count = 0;
+    }
+}
+static inline void unlock( simple_owner_lock & this ) with(this) {
         lock( lock __cfaabi_dbg_ctx2 );
         /* paranoid */ verifyf( owner != 0p, "Attempt to release lock %p that isn't held", &this );
 …
         recursion_count--;
         if ( recursion_count == 0 ) {
+                // pop_and_set_new_owner( this );
+                thread$ * t = &try_pop_front( blocked_threads );
+                owner = t;
+                recursion_count = ( t ? 1 : 0 );
+                unpark( t );
+                pop_node( this );
+        }
         unlock( lock );
+}
 static inline void on_notify(simple_owner_lock & this, struct thread$ * t ) with(this) {
+static inline void on_notify( simple_owner_lock & this, thread$ * t ) with(this) {
         lock( lock __cfaabi_dbg_ctx2 );
         // lock held
         if ( owner != 0p ) {
                 insert_last( blocked_threads, *t );
+                insert_last( blocked_threads, *(select_node *)t->link_node );
+        }
         // lock not held
 …
+}
 static inline size_t on_wait(simple_owner_lock & this) with(this) {
+static inline size_t on_wait( simple_owner_lock & this, __cfa_pre_park pp_fn, void * pp_datum ) with(this) {
         lock( lock __cfaabi_dbg_ctx2 );
         /* paranoid */ verifyf( owner != 0p, "Attempt to release lock %p that isn't held", &this );
 …
         size_t ret = recursion_count;
+        // pop_and_set_new_owner( this );
+        thread$ * t = &try_pop_front( blocked_threads );
+        owner = t;
+        recursion_count = ( t ? 1 : 0 );
+        unpark( t );
+        pop_node( this );
+    select_node node;
+    active_thread()->link_node = (void *)&node;
         unlock( lock );
+    pre_park_then_park( pp_fn, pp_datum );
         return ret;
+}
+static inline void on_wakeup(simple_owner_lock & this, size_t recursion ) with(this) { recursion_count = recursion; }
+static inline void on_wakeup( simple_owner_lock & this, size_t recursion ) with(this) { recursion_count = recursion; }
+// waituntil() support
+static inline bool register_select( simple_owner_lock & this, select_node & node ) with(this) {
+    lock( lock __cfaabi_dbg_ctx2 );
+    // check if we can complete operation. If so race to establish winner in special OR case
+    if ( !node.park_counter && ( owner == active_thread() || owner == 0p ) ) {
+        if ( !__make_select_node_available( node ) ) { // we didn't win the race so give up on registering
+           unlock( lock );
+           return false;
+        }
+    }
+    if ( owner == active_thread() ) {
+                recursion_count++;
+        if ( node.park_counter ) __make_select_node_available( node );
+        unlock( lock );
+                return true;
+        }
+    if ( owner != 0p ) {
+                insert_last( blocked_threads, node );
+                unlock( lock );
+                return false;
+        }
+        owner = active_thread();
+        recursion_count = 1;
+    if ( node.park_counter ) __make_select_node_available( node );
+    unlock( lock );
+    return true;
+}
+static inline bool unregister_select( simple_owner_lock & this, select_node & node ) with(this) {
+    lock( lock __cfaabi_dbg_ctx2 );
+    if ( node`isListed ) {
+        remove( node );
+        unlock( lock );
+        return false;
+    }
+    if ( owner == active_thread() ) {
+        recursion_count--;
+        if ( recursion_count == 0 ) {
+            pop_node( this );
+        }
+    }
+    unlock( lock );
+    return false;
+}
+static inline void on_selected( simple_owner_lock & this, select_node & node ) {}
 //-----------------------------------------------------------------------------
 …
         // flag showing if lock is held
         volatile bool held;
-        #ifdef __CFA_DEBUG__
-        // for deadlock detection
-        struct thread$ * owner;
-        #endif
 };
 …
 static inline void ?=?( spin_queue_lock & this, spin_queue_lock this2 ) = void;
 // if this is called recursively IT WILL DEADLOCK!!!!!
 static inline void lock(spin_queue_lock & this) with(this) {
+// if this is called recursively IT WILL DEADLOCK!
+static inline void lock( spin_queue_lock & this ) with(this) {
         mcs_spin_node node;
         lock( lock, node );
 …
+}
 static inline void unlock(spin_queue_lock & this) with(this) {
+static inline void unlock( spin_queue_lock & this ) with(this) {
         __atomic_store_n(&held, false, __ATOMIC_RELEASE);
+}
+static inline void on_notify(spin_queue_lock & this, struct thread$ * t ) {
+        unpark(t);
+}
+static inline size_t on_wait(spin_queue_lock & this) { unlock(this); return 0; }
+static inline void on_wakeup(spin_queue_lock & this, size_t recursion ) {
+        #ifdef REACQ
+        lock(this);
+        #endif
+}
+DEFAULT_ON_NOTIFY( spin_queue_lock )
+DEFAULT_ON_WAIT( spin_queue_lock )
+DEFAULT_ON_WAKEUP_REACQ( spin_queue_lock )
 //-----------------------------------------------------------------------------
 …
 // if this is called recursively IT WILL DEADLOCK!!!!!
 static inline void lock(mcs_block_spin_lock & this) with(this) {
+static inline void lock( mcs_block_spin_lock & this ) with(this) {
         mcs_node node;
         lock( lock, node );
 …
+}
+static inline void on_notify(mcs_block_spin_lock & this, struct thread$ * t ) { unpark(t); }
+static inline size_t on_wait(mcs_block_spin_lock & this) { unlock(this); return 0; }
+static inline void on_wakeup(mcs_block_spin_lock & this, size_t recursion ) {
+        #ifdef REACQ
+        lock(this);
+        #endif
+}
+DEFAULT_ON_NOTIFY( mcs_block_spin_lock )
+DEFAULT_ON_WAIT( mcs_block_spin_lock )
+DEFAULT_ON_WAKEUP_REACQ( mcs_block_spin_lock )
 //-----------------------------------------------------------------------------
 …
 // if this is called recursively IT WILL DEADLOCK!!!!!
 static inline void lock(block_spin_lock & this) with(this) {
+static inline void lock( block_spin_lock & this ) with(this) {
         lock( lock );
         while(__atomic_load_n(&held, __ATOMIC_SEQ_CST)) Pause();
 …
+}
 static inline void unlock(block_spin_lock & this) with(this) {
+static inline void unlock( block_spin_lock & this ) with(this) {
         __atomic_store_n(&held, false, __ATOMIC_RELEASE);
+}
+static inline void on_notify(block_spin_lock & this, struct thread$ * t ) with(this.lock) {
+  #ifdef REACQ
+static inline void on_notify( block_spin_lock & this, struct thread$ * t ) with(this.lock) {
         // first we acquire internal fast_block_lock
         lock( lock __cfaabi_dbg_ctx2 );
 …
         unlock( lock );
-  #endif
         unpark(t);
+}
+static inline size_t on_wait(block_spin_lock & this) { unlock(this); return 0; }
+static inline void on_wakeup(block_spin_lock & this, size_t recursion ) with(this) {
+  #ifdef REACQ
+}
+DEFAULT_ON_WAIT( block_spin_lock )
+static inline void on_wakeup( block_spin_lock & this, size_t recursion ) with(this) {
         // now we acquire the entire block_spin_lock upon waking up
         while(__atomic_load_n(&held, __ATOMIC_SEQ_CST)) Pause();
         __atomic_store_n(&held, true, __ATOMIC_RELEASE);
         unlock( lock ); // Now we release the internal fast_spin_lock
+  #endif
+}
+//-----------------------------------------------------------------------------
+// is_blocking_lock
+trait is_blocking_lock(L & | sized(L)) {
+        // For synchronization locks to use when acquiring
+        void on_notify( L &, struct thread$ * );
+        // For synchronization locks to use when releasing
+        size_t on_wait( L & );
+        // to set recursion count after getting signalled;
+        void on_wakeup( L &, size_t recursion );
+};
+}
 //-----------------------------------------------------------------------------
 …
 forall(L & | is_blocking_lock(L)) {
         struct info_thread;
-        // // for use by sequence
-        // info_thread(L) *& Back( info_thread(L) * this );
-        // info_thread(L) *& Next( info_thread(L) * this );
+}

libcfa/src/concurrency/monitor.cfa

-              r34b4268
+              r24d6572
 // Created On       : Thd Feb 23 12:27:26 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed Dec  4 07:55:14 2019
 // Update Count     : 10
+// Last Modified On : Sun Feb 19 17:00:59 2023
+// Update Count     : 12
 //
 #define __cforall_thread__
-#define _GNU_SOURCE
 #include "monitor.hfa"

libcfa/src/concurrency/monitor.hfa

-              r34b4268
+              r24d6572
 // Created On       : Thd Feb 23 12:27:26 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed Dec  4 07:55:32 2019
 // Update Count     : 11
+// Last Modified On : Thu Feb  2 11:29:21 2023
+// Update Count     : 12
 //
 …
 #include "stdlib.hfa"
+trait is_monitor(T &) {
+forall( T & )
+trait is_monitor {
         monitor$ * get_monitor( T & );
         void ^?{}( T & mutex );

libcfa/src/concurrency/mutex.cfa

-              r34b4268
+              r24d6572
 // Created On       : Fri May 25 01:37:11 2018
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed Dec  4 09:16:39 2019
 // Update Count     : 1
+// Last Modified On : Sun Feb 19 17:01:36 2023
+// Update Count     : 3
 //
 #define __cforall_thread__
-#define _GNU_SOURCE
 #include "mutex.hfa"

libcfa/src/concurrency/mutex.hfa

-              r34b4268
+              r24d6572
 // Created On       : Fri May 25 01:24:09 2018
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed Dec  4 09:16:53 2019
 // Update Count     : 1
+// Last Modified On : Thu Feb  2 11:46:08 2023
+// Update Count     : 2
 //
 …
 void unlock(recursive_mutex_lock & this) __attribute__((deprecated("use concurrency/locks.hfa instead")));
+trait is_lock(L & | sized(L)) {
+forall( L & | sized(L) )
+trait is_lock {
         void lock  (L &);
         void unlock(L &);

libcfa/src/concurrency/mutex_stmt.hfa

-              r34b4268
+              r24d6572
+#pragma once
 #include "bits/algorithm.hfa"
 #include "bits/defs.hfa"
 …
 //-----------------------------------------------------------------------------
 // is_lock
+trait is_lock(L & | sized(L)) {
+forall(L & | sized(L))
+trait is_lock {
         // For acquiring a lock
         void lock( L & );
 …
         void unlock( L & );
 };
 struct __mutex_stmt_lock_guard {
 …
     // Sort locks based on address
     __libcfa_small_sort(this.lockarr, count);
-    // acquire locks in order
-    // for ( size_t i = 0; i < count; i++ ) {
-    //     lock(*this.lockarr[i]);
-    // }
+}
-static inline void ^?{}( __mutex_stmt_lock_guard & this ) with(this) {
-    // for ( size_t i = count; i > 0; i-- ) {
-    //     unlock(*lockarr[i - 1]);
-    // }
+}
 forall(L & | is_lock(L)) {
+    struct scoped_lock {
+        L * internal_lock;
+    };
+    static inline void ?{}( scoped_lock(L) & this, L & internal_lock ) {
+        this.internal_lock = &internal_lock;
+        lock(internal_lock);
+    }
+    static inline void ^?{}( scoped_lock(L) & this ) with(this) {
+        unlock(*internal_lock);
+    }
+    static inline void * __get_mutexstmt_lock_ptr( L & this ) {
+        return &this;
+    }
+    static inline L __get_mutexstmt_lock_type( L & this );
+    static inline L __get_mutexstmt_lock_type( L * this );
+    static inline void * __get_mutexstmt_lock_ptr( L & this ) { return &this; }
+    static inline L __get_mutexstmt_lock_type( L & this ) {}
+    static inline L __get_mutexstmt_lock_type( L * this ) {}
+}

libcfa/src/concurrency/preemption.cfa

-              r34b4268
+              r24d6572
 // Created On       : Mon Jun 5 14:20:42 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Feb 17 11:18:57 2022
 // Update Count     : 59
+// Last Modified On : Mon Jan  9 08:42:59 2023
+// Update Count     : 60
 //
 #define __cforall_thread__
-#define _GNU_SOURCE
 // #define __CFA_DEBUG_PRINT_PREEMPTION__
 …
                 __cfadbg_print_buffer_decl( preemption, " KERNEL: preemption tick %lu\n", currtime.tn);
                 Duration period = node->period;
                 if( period == 0) {
+                if( period == 0 ) {
                         node->set = false;                  // Node is one-shot, just mark it as not pending
+                }

libcfa/src/concurrency/pthread.cfa

-              r34b4268
+              r24d6572
 #define __cforall_thread__
-#define _GNU_SOURCE
 #include <signal.h>
 …
 struct pthread_values{
         inline Seqable;
         void* value;
+        void * value;
         bool in_use;
 };
 …
 struct pthread_keys {
         bool in_use;
         void (*destructor)( void * );
+        void (* destructor)( void * );
         Sequence(pthread_values) threads;
 };
 static void ?{}(pthread_keys& k){
+static void ?{}(pthread_keys& k) {
         k.threads{};
+}
 …
 static pthread_keys cfa_pthread_keys_storage[PTHREAD_KEYS_MAX] __attribute__((aligned (16)));
 static void init_pthread_storage(){
         for (int i = 0; i < PTHREAD_KEYS_MAX; i++){
+static void init_pthread_storage() {
+        for ( int i = 0; i < PTHREAD_KEYS_MAX; i++ ) {
                 cfa_pthread_keys_storage[i]{};
+        }
 …
 /* condvar helper routines */
 static void init(pthread_cond_t* pcond){
+static void init(pthread_cond_t * pcond) {
         static_assert(sizeof(pthread_cond_t) >= sizeof(cfa2pthr_cond_var_t),"sizeof(pthread_t) < sizeof(cfa2pthr_cond_var_t)");
         cfa2pthr_cond_var_t* _cond = (cfa2pthr_cond_var_t*)pcond;
+        cfa2pthr_cond_var_t * _cond = (cfa2pthr_cond_var_t *)pcond;
         ?{}(*_cond);
+}
 static cfa2pthr_cond_var_t* get(pthread_cond_t* pcond){
+static cfa2pthr_cond_var_t * get(pthread_cond_t * pcond) {
         static_assert(sizeof(pthread_cond_t) >= sizeof(cfa2pthr_cond_var_t),"sizeof(pthread_t) < sizeof(cfa2pthr_cond_var_t)");
         return (cfa2pthr_cond_var_t*)pcond;
+}
 static void destroy(pthread_cond_t* cond){
+        return (cfa2pthr_cond_var_t *)pcond;
+}
+static void destroy(pthread_cond_t * cond) {
         static_assert(sizeof(pthread_cond_t) >= sizeof(cfa2pthr_cond_var_t),"sizeof(pthread_t) < sizeof(cfa2pthr_cond_var_t)");
         ^?{}(*get(cond));
 …
 /* mutex helper routines */
 static void mutex_check(pthread_mutex_t* t){
+static void mutex_check(pthread_mutex_t * t) {
         // Use double check to improve performance.
         // Check is safe on x86; volatile prevents compiler reordering
         volatile pthread_mutex_t *const mutex_ = t;
+        volatile pthread_mutex_t * const mutex_ = t;
         // SKULLDUGGERY: not a portable way to access the kind field, /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h
 …
 static void init(pthread_mutex_t* plock){
+static void init(pthread_mutex_t * plock) {
         static_assert(sizeof(pthread_mutex_t) >= sizeof(simple_owner_lock),"sizeof(pthread_mutex_t) < sizeof(simple_owner_lock)");
         simple_owner_lock* _lock = (simple_owner_lock*)plock;
+        simple_owner_lock * _lock = (simple_owner_lock *)plock;
         ?{}(*_lock);
+}
 static simple_owner_lock* get(pthread_mutex_t* plock){
+static simple_owner_lock * get(pthread_mutex_t * plock) {
         static_assert(sizeof(pthread_mutex_t) >= sizeof(simple_owner_lock),"sizeof(pthread_mutex_t) < sizeof(simple_owner_lock)");
         return (simple_owner_lock*)plock;
+}
 static void destroy(pthread_mutex_t* plock){
+        return (simple_owner_lock *)plock;
+}
+static void destroy(pthread_mutex_t * plock) {
         static_assert(sizeof(pthread_mutex_t) >= sizeof(simple_owner_lock),"sizeof(pthread_mutex_t) < sizeof(simple_owner_lock)");
         ^?{}(*get(plock));
 …
 //######################### Attr helpers #########################
 struct cfaPthread_attr_t {                                                              // thread attributes
+typedef struct cfaPthread_attr_t {                                              // thread attributes
                 int contentionscope;
                 int detachstate;
                 size_t stacksize;
                 void *stackaddr;
+                void * stackaddr;
                 int policy;
                 int inheritsched;
                 struct sched_param param;
 } typedef cfaPthread_attr_t;
 static const cfaPthread_attr_t default_attrs{
+} cfaPthread_attr_t;
+static const cfaPthread_attr_t default_attrs {
 ,
 ,
         (size_t)65000,
         (void *)NULL,
+_000,
+        NULL,
 ,
 ,
 …
 };
 static cfaPthread_attr_t* get(const pthread_attr_t* attr){
         static_assert(sizeof(pthread_attr_t) >= sizeof(cfaPthread_attr_t),"sizeof(pthread_attr_t) < sizeof(cfaPthread_attr_t)");
         return (cfaPthread_attr_t*)attr;
+static cfaPthread_attr_t * get(const pthread_attr_t * attr) {
+        static_assert(sizeof(pthread_attr_t) >= sizeof(cfaPthread_attr_t), "sizeof(pthread_attr_t) < sizeof(cfaPthread_attr_t)");
+        return (cfaPthread_attr_t *)attr;
+}
 …
         // pthreads return value
         void *joinval;
+        void * joinval;
         // pthread attributes
         pthread_attr_t pthread_attr;
         void *(*start_routine)(void *);
         void *start_arg;
+        void *(* start_routine)(void *);
+        void * start_arg;
         // thread local data
         pthread_values* pthreadData;
+        pthread_values * pthreadData;
         // flag used for tryjoin
 …
 /* thread part routines */
 //  cfaPthread entry point
 void main(cfaPthread& _thread) with(_thread){
         joinval =  start_routine(start_arg);
+void main(cfaPthread & _thread) with(_thread) {
+        joinval = start_routine(start_arg);
         isTerminated = true;
+}
 static cfaPthread *lookup( pthread_t p ){
         static_assert(sizeof(pthread_t) >= sizeof(cfaPthread*),"sizeof(pthread_t) < sizeof(cfaPthread*)");
         return (cfaPthread*)p;
+}
 static void pthread_deletespecific_( pthread_values* values )  { // see uMachContext::invokeTask
         pthread_values* value;
         pthread_keys* key;
+static cfaPthread * lookup( pthread_t p ) {
+        static_assert(sizeof(pthread_t) >= sizeof(cfaPthread *),"sizeof(pthread_t) < sizeof(cfaPthread *)");
+        return (cfaPthread *)p;
+}
+static void pthread_deletespecific_( pthread_values * values )  { // see uMachContext::invokeTask
+        pthread_values * value;
+        pthread_keys * key;
         bool destcalled = true;
         if (values != NULL){
+        if (values != NULL) {
                 for ( int attempts = 0; attempts < PTHREAD_DESTRUCTOR_ITERATIONS && destcalled ; attempts += 1 ) {
                         destcalled = false;
                         lock(key_lock);
                         for (int i = 0; i < PTHREAD_KEYS_MAX; i++){
+                        for ( int i = 0; i < PTHREAD_KEYS_MAX; i++ ) {
                                 // for each valid key
                                 if ( values[i].in_use){
+                                if ( values[i].in_use) {
                                         value = &values[i];
                                         key = &cfa_pthread_keys[i];
 …
                                         // if  a  key  value  has  a  non-NULL  destructor pointer,  and  the  thread  has  a  non-NULL  value associated with that key,
                                         // the value of the key is set to NULL, and then the function pointed to is called with the previously associated value as its sole argument.
                                         if (value->value != NULL && key->destructor != NULL){
+                                        if (value->value != NULL && key->destructor != NULL) {
                                                 unlock(key_lock);
                                                 key->destructor(value->value); // run destructor
 …
+}
 static void ^?{}(cfaPthread & mutex t){
+static void ^?{}(cfaPthread & mutex t) {
         // delete pthread local storage
         pthread_values * values = t.pthreadData;
 …
+}
 static void ?{}(cfaPthread &t, pthread_t* _thread, const pthread_attr_t * _attr,void *(*start_routine)(void *), void * arg) {
         static_assert(sizeof(pthread_t) >= sizeof(cfaPthread*), "pthread_t too small to hold a pointer: sizeof(pthread_t) < sizeof(cfaPthread*)");
+static void ?{}(cfaPthread & t, pthread_t * _thread, const pthread_attr_t * _attr,void *(* start_routine)(void *), void * arg) {
+        static_assert(sizeof(pthread_t) >= sizeof(cfaPthread *), "pthread_t too small to hold a pointer: sizeof(pthread_t) < sizeof(cfaPthread *)");
         // set up user thread stackSize
 …
         //######################### Pthread Attrs #########################
         int pthread_attr_init(pthread_attr_t *attr) libcfa_public __THROW {
                 cfaPthread_attr_t* _attr = get(attr);
+        int pthread_attr_init(pthread_attr_t * attr) libcfa_public __THROW {
+                cfaPthread_attr_t * _attr = get(attr);
                 ?{}(*_attr, default_attrs);
                 return 0;
+        }
         int pthread_attr_destroy(pthread_attr_t *attr) libcfa_public __THROW {
+        int pthread_attr_destroy(pthread_attr_t * attr) libcfa_public __THROW {
                 ^?{}(*get(attr));
                 return 0;
+        }
         int pthread_attr_setscope( pthread_attr_t *attr, int contentionscope ) libcfa_public __THROW {
+        int pthread_attr_setscope( pthread_attr_t * attr, int contentionscope ) libcfa_public __THROW {
                 get( attr )->contentionscope = contentionscope;
                 return 0;
         } // pthread_attr_setscope
         int pthread_attr_getscope( const pthread_attr_t *attr, int *contentionscope ) libcfa_public __THROW {
+        int pthread_attr_getscope( const pthread_attr_t * attr, int * contentionscope ) libcfa_public __THROW {
                 *contentionscope = get( attr )->contentionscope;
                 return 0;
         } // pthread_attr_getscope
         int pthread_attr_setdetachstate( pthread_attr_t *attr, int detachstate ) libcfa_public __THROW {
+        int pthread_attr_setdetachstate( pthread_attr_t * attr, int detachstate ) libcfa_public __THROW {
                 get( attr )->detachstate = detachstate;
                 return 0;
         } // pthread_attr_setdetachstate
         int pthread_attr_getdetachstate( const pthread_attr_t *attr, int *detachstate ) libcfa_public __THROW {
+        int pthread_attr_getdetachstate( const pthread_attr_t * attr, int * detachstate ) libcfa_public __THROW {
                 *detachstate = get( attr )->detachstate;
                 return 0;
         } // pthread_attr_getdetachstate
         int pthread_attr_setstacksize( pthread_attr_t *attr, size_t stacksize ) libcfa_public __THROW {
+        int pthread_attr_setstacksize( pthread_attr_t * attr, size_t stacksize ) libcfa_public __THROW {
                 get( attr )->stacksize = stacksize;
                 return 0;
         } // pthread_attr_setstacksize
         int pthread_attr_getstacksize( const pthread_attr_t *attr, size_t *stacksize ) libcfa_public __THROW {
+        int pthread_attr_getstacksize( const pthread_attr_t * attr, size_t * stacksize ) libcfa_public __THROW {
                 *stacksize = get( attr )->stacksize;
                 return 0;
 …
         } // pthread_attr_setguardsize
         int pthread_attr_setstackaddr( pthread_attr_t *attr, void *stackaddr ) libcfa_public __THROW {
+        int pthread_attr_setstackaddr( pthread_attr_t * attr, void * stackaddr ) libcfa_public __THROW {
                 get( attr )->stackaddr = stackaddr;
                 return 0;
         } // pthread_attr_setstackaddr
         int pthread_attr_getstackaddr( const pthread_attr_t *attr, void **stackaddr ) libcfa_public __THROW {
+        int pthread_attr_getstackaddr( const pthread_attr_t * attr, void ** stackaddr ) libcfa_public __THROW {
                 *stackaddr = get( attr )->stackaddr;
                 return 0;
         } // pthread_attr_getstackaddr
         int pthread_attr_setstack( pthread_attr_t *attr, void *stackaddr, size_t stacksize ) libcfa_public __THROW {
+        int pthread_attr_setstack( pthread_attr_t * attr, void * stackaddr, size_t stacksize ) libcfa_public __THROW {
                 get( attr )->stackaddr = stackaddr;
                 get( attr )->stacksize = stacksize;
 …
         } // pthread_attr_setstack
         int pthread_attr_getstack( const pthread_attr_t *attr, void **stackaddr, size_t *stacksize ) libcfa_public __THROW {
+        int pthread_attr_getstack( const pthread_attr_t * attr, void ** stackaddr, size_t * stacksize ) libcfa_public __THROW {
                 *stackaddr = get( attr )->stackaddr;
                 *stacksize = get( attr )->stacksize;
 …
         // already running thread threadID. It shall be called on unitialized attr
         // and destroyed with pthread_attr_destroy when no longer needed.
         int pthread_getattr_np( pthread_t threadID, pthread_attr_t *attr ) libcfa_public __THROW { // GNU extension
+        int pthread_getattr_np( pthread_t threadID, pthread_attr_t * attr ) libcfa_public __THROW { // GNU extension
                 check_nonnull(attr);
 …
         //######################### Threads #########################
         int pthread_create(pthread_t * _thread, const pthread_attr_t * attr, void *(*start_routine)(void *), void * arg) libcfa_public __THROW {
                 cfaPthread *t = alloc();
+        int pthread_create(pthread_t * _thread, const pthread_attr_t * attr, void *(* start_routine)(void *), void * arg) libcfa_public __THROW {
+                cfaPthread * t = alloc();
                 (*t){_thread, attr, start_routine, arg};
                 return 0;
+        }
+        int pthread_join(pthread_t _thread, void **value_ptr) libcfa_public __THROW {
+        int pthread_join(pthread_t _thread, void ** value_ptr) libcfa_public __THROW {
                 // if thread is invalid
                 if (_thread == NULL) return EINVAL;
 …
                 // get user thr pointer
                 cfaPthread* p = lookup(_thread);
+                cfaPthread * p = lookup(_thread);
                 try {
                         join(*p);
 …
+        }
         int pthread_tryjoin_np(pthread_t _thread, void **value_ptr) libcfa_public __THROW {
+        int pthread_tryjoin_np(pthread_t _thread, void ** value_ptr) libcfa_public __THROW {
                 // if thread is invalid
                 if (_thread == NULL) return EINVAL;
                 if (_thread == pthread_self()) return EDEADLK;
                 cfaPthread* p = lookup(_thread);
+                cfaPthread * p = lookup(_thread);
                 // thread not finished ?
 …
         void pthread_exit(void * status) libcfa_public __THROW {
                 pthread_t pid = pthread_self();
                 cfaPthread* _thread = (cfaPthread*)pid;
+                cfaPthread * _thread = (cfaPthread *)pid;
                 _thread->joinval = status;  // set return value
                 _thread->isTerminated = 1;  // set terminated flag
 …
         //######################### Mutex #########################
         int pthread_mutex_init(pthread_mutex_t *_mutex, const pthread_mutexattr_t *attr) libcfa_public __THROW {
+        int pthread_mutex_init(pthread_mutex_t *_mutex, const pthread_mutexattr_t * attr) libcfa_public __THROW {
                 check_nonnull(_mutex);
                 init(_mutex);
 …
         int pthread_mutex_destroy(pthread_mutex_t *_mutex) libcfa_public __THROW {
                 check_nonnull(_mutex);
                 simple_owner_lock* _lock = get(_mutex);
                 if (_lock->owner != NULL){
+                simple_owner_lock * _lock = get(_mutex);
+                if (_lock->owner != NULL) {
                         return EBUSY;
+                }
 …
                 check_nonnull(_mutex);
                 mutex_check(_mutex);
                 simple_owner_lock* _lock = get(_mutex);
+                simple_owner_lock * _lock = get(_mutex);
                 lock(*_lock);
                 return 0;
 …
         int pthread_mutex_unlock(pthread_mutex_t *_mutex) libcfa_public __THROW {
                 check_nonnull(_mutex);
                 simple_owner_lock* _lock = get(_mutex);
                 if (_lock->owner != active_thread()){
+                simple_owner_lock * _lock = get(_mutex);
+                if (_lock->owner != active_thread()) {
                         return EPERM;
                 } // current thread does not hold the mutex
 …
         int pthread_mutex_trylock(pthread_mutex_t *_mutex) libcfa_public __THROW {
                 check_nonnull(_mutex);
                 simple_owner_lock* _lock = get(_mutex);
                 if (_lock->owner != active_thread() && _lock->owner != NULL){
+                simple_owner_lock * _lock = get(_mutex);
+                if (_lock->owner != active_thread() && _lock->owner != NULL) {
                         return EBUSY;
                 }   // if mutex is owned
 …
         /* conditional variable routines */
         int pthread_cond_init(pthread_cond_t *cond, const pthread_condattr_t *attr) libcfa_public __THROW {
+        int pthread_cond_init(pthread_cond_t * cond, const pthread_condattr_t * attr) libcfa_public __THROW {
                 check_nonnull(cond);
                 init(cond);
 …
         }  //pthread_cond_init
         int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *_mutex) libcfa_public __THROW {
+        int pthread_cond_wait(pthread_cond_t * cond, pthread_mutex_t *_mutex) libcfa_public __THROW {
                 check_nonnull(_mutex);
                 check_nonnull(cond);
 …
         } // pthread_cond_timedwait
         int pthread_cond_signal(pthread_cond_t *cond) libcfa_public __THROW {
+        int pthread_cond_signal(pthread_cond_t * cond) libcfa_public __THROW {
                 check_nonnull(cond);
                 return notify_one(*get(cond));
         } // pthread_cond_signal
         int pthread_cond_broadcast(pthread_cond_t *cond) libcfa_public __THROW {
+        int pthread_cond_broadcast(pthread_cond_t * cond) libcfa_public __THROW {
                 check_nonnull(cond);
                 return notify_all(*get(cond));
         } // pthread_cond_broadcast
         int pthread_cond_destroy(pthread_cond_t *cond) libcfa_public __THROW {
+        int pthread_cond_destroy(pthread_cond_t * cond) libcfa_public __THROW {
                 check_nonnull(cond);
                 destroy(cond);
 …
         //######################### Local storage #########################
         int pthread_once(pthread_once_t *once_control, void (*init_routine)(void)) libcfa_public __THROW {
+        int pthread_once(pthread_once_t * once_control, void (* init_routine)(void)) libcfa_public __THROW {
                 static_assert(sizeof(pthread_once_t) >= sizeof(int),"sizeof(pthread_once_t) < sizeof(int)");
                 check_nonnull(once_control);
 …
         } // pthread_once
         int pthread_key_create( pthread_key_t *key, void (*destructor)( void * ) ) libcfa_public __THROW {
+        int pthread_key_create( pthread_key_t * key, void (* destructor)( void * ) ) libcfa_public __THROW {
                 lock(key_lock);
                 for ( int i = 0; i < PTHREAD_KEYS_MAX; i += 1 ) {
 …
         }   // pthread_key_delete
         int pthread_setspecific( pthread_key_t key, const void *value ) libcfa_public __THROW {
+        int pthread_setspecific( pthread_key_t key, const void * value ) libcfa_public __THROW {
                 // get current thread
                 cfaPthread* t = lookup(pthread_self());
+                cfaPthread * t = lookup(pthread_self());
                 // if current thread's pthreadData is NULL; initialize it
                 pthread_values* values;
                 if (t->pthreadData == NULL){
+                pthread_values * values;
+                if (t->pthreadData == NULL) {
                         values = anew( PTHREAD_KEYS_MAX);
                         t->pthreadData = values;
                         for (int i = 0;i < PTHREAD_KEYS_MAX; i++){
+                        for ( int i = 0;i < PTHREAD_KEYS_MAX; i++ ) {
                                 t->pthreadData[i].in_use = false;
                         }   // for
 …
         } //pthread_setspecific
         void* pthread_getspecific(pthread_key_t key) libcfa_public __THROW {
+        void * pthread_getspecific(pthread_key_t key) libcfa_public __THROW {
                 if (key >= PTHREAD_KEYS_MAX || ! cfa_pthread_keys[key].in_use) return NULL;
                 // get current thread
                 cfaPthread* t = lookup(pthread_self());
+                cfaPthread * t = lookup(pthread_self());
                 if (t->pthreadData == NULL) return NULL;
                 lock(key_lock);
                 pthread_values &entry = ((pthread_values *)t->pthreadData)[key];
+                pthread_values & entry = ((pthread_values *)t->pthreadData)[key];
                 if ( ! entry.in_use ) {
                         unlock( key_lock );
                         return NULL;
                 } // if
                 void *value = entry.value;
+                void * value = entry.value;
                 unlock(key_lock);
 …
         //######################### Parallelism #########################
         int pthread_setaffinity_np( pthread_t /* __th */, size_t /* __cpusetsize */, __const cpu_set_t * /* __cpuset */ ) libcfa_public __THROW {
                 abort( "pthread_setaffinity_np" );
         } // pthread_setaffinity_np
         int pthread_getaffinity_np( pthread_t /* __th */, size_t /* __cpusetsize */, cpu_set_t * /* __cpuset */ ) libcfa_public __THROW {
                 abort( "pthread_getaffinity_np" );
         } // pthread_getaffinity_np
         int pthread_attr_setaffinity_np( pthread_attr_t * /* __attr */, size_t /* __cpusetsize */, __const cpu_set_t * /* __cpuset */ ) libcfa_public __THROW {
                 abort( "pthread_attr_setaffinity_np" );
         } // pthread_attr_setaffinity_np
         int pthread_attr_getaffinity_np( __const pthread_attr_t * /* __attr */, size_t /* __cpusetsize */, cpu_set_t * /* __cpuset */ ) libcfa_public __THROW {
                 abort( "pthread_attr_getaffinity_np" );
         } // pthread_attr_getaffinity_np
+        // int pthread_setaffinity_np( pthread_t /* __th */, size_t /* __cpusetsize */, __const cpu_set_t * /* __cpuset */ ) libcfa_public __THROW {
+        //      abort( "pthread_setaffinity_np" );
+        // } // pthread_setaffinity_np
+        // int pthread_getaffinity_np( pthread_t /* __th */, size_t /* __cpusetsize */, cpu_set_t * /* __cpuset */ ) libcfa_public __THROW {
+        //      abort( "pthread_getaffinity_np" );
+        // } // pthread_getaffinity_np
+        // int pthread_attr_setaffinity_np( pthread_attr_t * /* __attr */, size_t /* __cpusetsize */, __const cpu_set_t * /* __cpuset */ ) libcfa_public __THROW {
+        //      abort( "pthread_attr_setaffinity_np" );
+        // } // pthread_attr_setaffinity_np
+        // int pthread_attr_getaffinity_np( __const pthread_attr_t * /* __attr */, size_t /* __cpusetsize */, cpu_set_t * /* __cpuset */ ) libcfa_public __THROW {
+        //      abort( "pthread_attr_getaffinity_np" );
+        // } // pthread_attr_getaffinity_np
         //######################### Cancellation #########################
 …
         } // pthread_cancel
         int pthread_setcancelstate( int state, int *oldstate ) libcfa_public __THROW {
+        int pthread_setcancelstate( int state, int * oldstate ) libcfa_public __THROW {
                 abort("pthread_setcancelstate not implemented");
                 return 0;
         } // pthread_setcancelstate
         int pthread_setcanceltype( int type, int *oldtype ) libcfa_public __THROW {
+        int pthread_setcanceltype( int type, int * oldtype ) libcfa_public __THROW {
                 abort("pthread_setcanceltype not implemented");
                 return 0;
 …
 #pragma GCC diagnostic pop

libcfa/src/concurrency/ready_queue.cfa

r34b4268	r24d6572
15	15
16	16	#define __cforall_thread__
17		~~#define _GNU_SOURCE~~
18	17
19	18	// #define __CFA_DEBUG_PRINT_READY_QUEUE__

libcfa/src/concurrency/thread.cfa

-              r34b4268
+              r24d6572
 // Created On       : Tue Jan 17 12:27:26 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sun Dec 11 20:56:54 2022
 // Update Count     : 102
+// Last Modified On : Mon Jan  9 08:42:33 2023
+// Update Count     : 103
 //
 #define __cforall_thread__
-#define _GNU_SOURCE
 #include "thread.hfa"
 …
         preferred = ready_queue_new_preferred();
         last_proc = 0p;
+    link_node = 0p;
         PRNG_SET_SEED( random_state, __global_random_mask ? __global_random_prime : __global_random_prime ^ rdtscl() );
         #if defined( __CFA_WITH_VERIFY__ )
 …
         #endif
-        clh_node = malloc( );
-        *clh_node = false;
         doregister(curr_cluster, this);
         monitors{ &self_mon_p, 1, (fptr_t)0 };
 …
                 canary = 0xDEADDEADDEADDEADp;
         #endif
-        free(clh_node);
         unregister(curr_cluster, this);
         ^self_cor{};

libcfa/src/concurrency/thread.hfa

-              r34b4268
+              r24d6572
 // Created On       : Tue Jan 17 12:27:26 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Tue Nov 22 22:18:34 2022
 // Update Count     : 35
+// Last Modified On : Thu Feb  2 11:27:59 2023
+// Update Count     : 37
 //
 …
 //-----------------------------------------------------------------------------
 // thread trait
+trait is_thread(T &) {
+forall( T & )
+trait is_thread {
         void ^?{}(T& mutex this);
         void main(T& this);

libcfa/src/containers/array.hfa

-              r34b4268
+              r24d6572
+//
+// Single-dim array sruct (with explicit packing and atom)
+//
+//
+// The `array` macro is the public interface.
+// It computes the type of a dense (trivially strided) array.
+// All user-declared objects are dense arrays.
+//
+// The `arpk` (ARray with PacKing info explicit) type is, generally, a slice with _any_ striding.
+// This type is meant for internal use.
+// CFA programmers should not instantiate it directly, nor access its field.
+// CFA programmers should call ?[?] on it.
+// Yet user-given `array(stuff)` expands to `arpk(stuff')`.
+// The comments here explain the resulting internals.
+//
+// Just as a plain-C "multidimesional" array is really array-of-array-of-...,
+// so does arpk generally show up as arpk-of-arpk-of...
+//
+// In the example of `array(float, 3, 4, 5) a;`,
+// `typeof(a)` is an `arpk` instantiation.
+// These comments explain _its_ arguments, i.e. those of the topmost `arpk` level.
+//
+// [N]    : the number of elements in `a`; 3 in the example
+// S      : carries the stride size (distance in bytes between &myA[0] and &myA[1]), in sizeof(S);
+//          same as Timmed when striding is trivial, same as Timmed in the example
+// Timmed : (T-immediate) the inner type; conceptually, `typeof(a)` is "arpk of Timmed";
+//          array(float, 4, 5) in the example
+// Tbase  : (T-base) the deepest element type that is not arpk; float in the example
+//
 forall( [N], S & | sized(S), Timmed &, Tbase & ) {
+    //
+    // Single-dim array sruct (with explicit packing and atom)
+    //
     struct arpk {
         S strides[N];

libcfa/src/containers/list.hfa

-              r34b4268
+              r24d6572
 // Author           : Michael Brooks
 // Created On       : Wed Apr 22 18:00:00 2020
 // Last Modified By : Michael Brooks
 // Last Modified On : Wed Apr 22 18:00:00 2020
 // Update Count     : 1
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Thu Feb  2 11:32:26 2023
+// Update Count     : 2
 //
 …
 };
+trait embedded( tOuter &, tMid &, tInner & ) {
+forall( tOuter &, tMid &, tInner & )
+trait embedded {
     tytagref( tMid, tInner ) ?`inner( tOuter & );
 };
 …
 static inline tytagref(void, T) ?`inner ( T & this ) { tytagref( void, T ) ret = {this}; return ret; }
+// use this on every case of plan-9 inheritance, to make embedded a closure of plan-9 inheritance
+#define P9_EMBEDDED( derived, immedBase ) \
+forall( Tbase &, TdiscardPath & | { tytagref( TdiscardPath, Tbase ) ?`inner( immedBase & ); } ) \
+    static inline tytagref(immedBase, Tbase) ?`inner( derived & this ) { \
+//
+// P9_EMBEDDED: Use on every case of plan-9 inheritance, to make "implements embedded" be a closure of plan-9 inheritance.
+//
+// struct foo {
+//    int a, b, c;
+//    inline (bar);
+// };
+// P9_EMBEDDED( foo, bar )
+//
+// usual version, for structs that are top-level declarations
+#define P9_EMBEDDED(        derived, immedBase ) P9_EMBEDDED_DECL_( derived, immedBase, static ) P9_EMBEDDED_BDY_( immedBase )
+// special version, for structs that are declared in functions
+#define P9_EMBEDDED_INFUNC( derived, immedBase ) P9_EMBEDDED_DECL_( derived, immedBase,        ) P9_EMBEDDED_BDY_( immedBase )
+// forward declarations of both the above; generally not needed
+// may help you control where the P9_EMBEEDED cruft goes, in case "right after the stuct" isn't where you want it
+#define P9_EMBEDDED_FWD(        derived, immedBase )      P9_EMBEDDED_DECL_( derived, immedBase, static ) ;
+#define P9_EMBEDDED_FWD_INFUNC( derived, immedBase ) auto P9_EMBEDDED_DECL_( derived, immedBase,        ) ;
+// private helpers
+#define P9_EMBEDDED_DECL_( derived, immedBase, STORAGE ) \
+    forall( Tbase &, TdiscardPath & | { tytagref( TdiscardPath, Tbase ) ?`inner( immedBase & ); } ) \
+    STORAGE inline tytagref(immedBase, Tbase) ?`inner( derived & this )
+#define P9_EMBEDDED_BDY_( immedBase ) { \
         immedBase & ib = this; \
         Tbase & b = ib`inner; \

libcfa/src/containers/vector.hfa

-              r34b4268
+              r24d6572
 // Created On       : Tue Jul  5 18:00:07 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed Jun 17 11:02:46 2020
 // Update Count     : 4
+// Last Modified On : Thu Feb  2 11:41:24 2023
+// Update Count     : 5
 //
 …
 //------------------------------------------------------------------------------
 //Declaration
 trait allocator_c(T, allocator_t)
+{
+forall( T, allocator_t )
+trait allocator_c {
         void realloc_storage(allocator_t*, size_t);
         T* data(allocator_t*);

libcfa/src/containers/vector2.hfa

-              r34b4268
+              r24d6572
 // Author           : Michael Brooks
 // Created On       : Thu Jun 23 22:00:00 2021
+// Last Modified By : Michael Brooks
+// Last Modified On : Thu Jun 23 22:00:00 2021
+// Update Count     : 1
+//
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Tue Mar 14 08:40:53 2023
+// Update Count     : 2
+//
+#pragma once
 #include <stdlib.hfa>

libcfa/src/exception.h

-              r34b4268
+              r24d6572
 // Author           : Andrew Beach
 // Created On       : Mon Jun 26 15:11:00 2017
 // Last Modified By : Andrew Beach
 // Last Modified On : Thr Apr  8 15:20:00 2021
 // Update Count     : 12
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Thu Feb  2 11:20:19 2023
+// Update Count     : 13
 //
 …
 // implemented in the .c file either so they all have to be inline.
+trait is_exception(exceptT &, virtualT &) {
+forall( exceptT &, virtualT & )
+trait is_exception {
         /* The first field must be a pointer to a virtual table.
          * That virtual table must be a decendent of the base exception virtual table.
 …
 };
+trait is_termination_exception(exceptT &, virtualT & | is_exception(exceptT, virtualT)) {
+forall( exceptT &, virtualT & | is_exception(exceptT, virtualT) )
+trait is_termination_exception {
         void defaultTerminationHandler(exceptT &);
 };
+trait is_resumption_exception(exceptT &, virtualT & | is_exception(exceptT, virtualT)) {
+forall( exceptT &, virtualT & | is_exception(exceptT, virtualT) )
+trait is_resumption_exception {
         void defaultResumptionHandler(exceptT &);
 };

libcfa/src/heap.cfa

-              r34b4268
+              r24d6572
 // Created On       : Tue Dec 19 21:58:35 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sun Oct 30 20:56:20 2022
 // Update Count     : 1584
+// Last Modified On : Fri Dec 30 08:37:37 2022
+// Update Count     : 1605
 //
 …
 #include <string.h>                                                                             // memset, memcpy
 #include <limits.h>                                                                             // ULONG_MAX
-#include <stdlib.h>                                                                             // EXIT_FAILURE
 #include <errno.h>                                                                              // errno, ENOMEM, EINVAL
+#include <unistd.h>                                                                             // STDERR_FILENO, sbrk, sysconf
+#include <malloc.h>                                                                             // memalign, malloc_usable_size
+#include <unistd.h>                                                                             // STDERR_FILENO, sbrk, sysconf, write
 #include <sys/mman.h>                                                                   // mmap, munmap
 extern "C" {
 …
 } // extern "C"
+#include "heap.hfa"
 #include "bits/align.hfa"                                                               // libAlign
 #include "bits/defs.hfa"                                                                // likely, unlikely
 …
 #endif
 typedef volatile uintptr_t SpinLock_t CALIGN;                   // aligned addressable word-size
+typedef volatile uintptr_t SpinLock_t;
 static inline __attribute__((always_inline)) void lock( volatile SpinLock_t & slock ) {
 …
         for ( unsigned int i = 1;; i += 1 ) {
           if ( slock == 0 && __atomic_test_and_set( &slock, __ATOMIC_SEQ_CST ) == 0 ) break; // Fence
+          if ( slock == 0 && __atomic_test_and_set( &slock, __ATOMIC_ACQUIRE ) == 0 ) break; // Fence
                 for ( volatile unsigned int s = 0; s < spin; s += 1 ) Pause(); // exponential spin
                 spin += spin;                                                                   // powers of 2
 …
 static inline __attribute__((always_inline)) void unlock( volatile SpinLock_t & slock ) {
         __atomic_clear( &slock, __ATOMIC_SEQ_CST );                     // Fence
+        __atomic_clear( &slock, __ATOMIC_RELEASE );                     // Fence
 } // spin_unlock
 …
         static_assert( libAlign() >= sizeof( Storage ), "minimum alignment < sizeof( Storage )" );
         struct __attribute__(( aligned (8) )) FreeHeader {
                 size_t blockSize __attribute__(( aligned(8) )); // size of allocations on this list
+        struct CALIGN FreeHeader {
+                size_t blockSize CALIGN;                                                // size of allocations on this list
                 #ifdef OWNERSHIP
                 #ifdef RETURNSPIN
 …
         #ifdef __CFA_DEBUG__
         int64_t allocUnfreed;                                                           // running total of allocations minus frees; can be negative
+        ptrdiff_t allocUnfreed;                                                         // running total of allocations minus frees; can be negative
         #endif // __CFA_DEBUG__
 …
 // Thread-local storage is allocated lazily when the storage is accessed.
 static __thread size_t PAD1 CALIGN TLSMODEL __attribute__(( unused )); // protect false sharing
 static __thread Heap * volatile heapManager CALIGN TLSMODEL;
+static __thread Heap * heapManager CALIGN TLSMODEL;
 static __thread size_t PAD2 CALIGN TLSMODEL __attribute__(( unused )); // protect further false sharing
 …
                 // 12K ~= 120K byte superblock.  Where 128-heap superblock handles a medium sized multi-processor server.
                 size_t remaining = heapManagersStorageEnd - heapManagersStorage; // remaining free heaps in superblock
                 if ( ! heapManagersStorage || remaining != 0 ) {
+                if ( ! heapManagersStorage || remaining == 0 ) {
                         // Each block of heaps is a multiple of the number of cores on the computer.
                         int HeapDim = get_nprocs();                                     // get_nprocs_conf does not work
 …
                 // allocUnfreed is set to 0 when a heap is created and it accumulates any unfreed storage during its multiple thread
                 // usages.  At the end, add up each heap allocUnfreed value across all heaps to get the total unfreed storage.
                 int64_t allocUnfreed = 0;
+                ptrdiff_t allocUnfreed = 0;
                 for ( Heap * heap = heapMaster.heapManagersList; heap; heap = heap->nextHeapManager ) {
                         allocUnfreed += heap->allocUnfreed;
 …
                         char helpText[512];
                         __cfaabi_bits_print_buffer( STDERR_FILENO, helpText, sizeof(helpText),
                                                                                 "CFA warning (UNIX pid:%ld) : program terminating with %ju(0x%jx) bytes of storage allocated but not freed.\n"
+                                                                                "CFA warning (UNIX pid:%ld) : program terminating with %td(%#tx) bytes of storage allocated but not freed.\n"
                                                                                 "Possible cause is unfreed storage allocated by the program or system/library routines called from the program.\n",
                                                                                 (long int)getpid(), allocUnfreed, allocUnfreed ); // always print the UNIX pid
 …
         ptrdiff_t rem = heapRemaining - size;
         if ( unlikely( rem < 0 ) ) {
+        if ( unlikely( rem < 0 ) ) {                                            // negative ?
                 // If the size requested is bigger than the current remaining storage, increase the size of the heap.
 …
         ptrdiff_t rem = heapReserve - size;
         if ( unlikely( rem < 0 ) ) {                                            // negative
+        if ( unlikely( rem < 0 ) ) {                                            // negative ?
                 // If the size requested is bigger than the current remaining reserve, use the current reserve to populate
                 // smaller freeLists, and increase the reserve.
 …
                 rem = heapReserve;                                                              // positive
                 if ( rem >= bucketSizes[0] ) {                                  // minimal size ? otherwise ignore
+                if ( (unsigned int)rem >= bucketSizes[0] ) {    // minimal size ? otherwise ignore
                         size_t bucket;
                         #ifdef FASTLOOKUP
 …
                         Heap.FreeHeader * freeHead = &(freeLists[bucket]);
                         // The remaining storage many not be bucket size, whereas all other allocations are. Round down to previous
+                        // The remaining storage may not be bucket size, whereas all other allocations are. Round down to previous
                         // bucket size in this case.
                         if ( unlikely( freeHead->blockSize > (size_t)rem ) ) freeHead -= 1;
 …
                 block = freeHead->freeList;                                             // remove node from stack
                 if ( unlikely( block == 0p ) ) {                                // no free block ?
                         // Freelist for this size is empty, so check return list (OWNERSHIP), carve it out of the heap, if there
+                        // Freelist for this size is empty, so check return list (OWNERSHIP), or carve it out of the heap if there
                         // is enough left, or get some more heap storage and carve it off.
                         #ifdef OWNERSHIP
 …
                         while ( ! __atomic_compare_exchange_n( &freeHead->returnList, &header->kind.real.next, (Heap.Storage *)header,
                                                                                                    false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST ) );
+                        #ifdef __STATISTICS__
+                        stats.return_pushes += 1;
+                        stats.return_storage_request += rsize;
+                        stats.return_storage_alloc += size;
+                        #endif // __STATISTICS__
                         #endif // RETURNSPIN
                 } // if
 …
                 freeHead->freeList = (Heap.Storage *)header;
                 #endif // ! OWNERSHIP
-                #ifdef __U_STATISTICS__
-                stats.return_pushes += 1;
-                stats.return_storage_request += rsize;
-                stats.return_storage_alloc += size;
-                #endif // __U_STATISTICS__
                 // OK TO BE PREEMPTED HERE AS heapManager IS NO LONGER ACCESSED.
 …
 #ifdef __STATISTICS__
 static void incCalls( intptr_t statName ) libcfa_nopreempt {
+static void incCalls( size_t statName ) libcfa_nopreempt {
         heapManager->stats.counters[statName].calls += 1;
 } // incCalls
 static void incZeroCalls( intptr_t statName ) libcfa_nopreempt {
+static void incZeroCalls( size_t statName ) libcfa_nopreempt {
         heapManager->stats.counters[statName].calls_0 += 1;
 } // incZeroCalls
 …
         // 0p, no operation is performed.
         void free( void * addr ) libcfa_public {
-//              verify( heapManager );
           if ( unlikely( addr == 0p ) ) {                                       // special case
                         #ifdef __STATISTICS__

libcfa/src/interpose.cfa

-              r34b4268
+              r24d6572
 // Created On       : Wed Mar 29 16:10:31 2017
 // Last Modified By : Peter A. Buhr
+// Last Modified On : Fri Mar 13 17:35:37 2020
+// Update Count     : 178
+//
+#include <stdarg.h>                                                                             // va_start, va_end
+// Last Modified On : Mon Mar 27 21:09:03 2023
+// Update Count     : 196
+//
 #include <stdio.h>
-#include <string.h>                                                                             // strlen
 #include <unistd.h>                                                                             // _exit, getpid
-#define __USE_GNU
-#include <signal.h>
-#undef __USE_GNU
 extern "C" {
 #include <dlfcn.h>                                                                              // dlopen, dlsym
 …
+}
-#include "bits/debug.hfa"
 #include "bits/defs.hfa"
 #include "bits/signal.hfa"                                                              // sigHandler_?
 …
 typedef void (* generic_fptr_t)(void);
 static generic_fptr_t do_interpose_symbol( void * library, const char symbol[], const char version[] ) {
-        const char * error;
         union { generic_fptr_t fptr; void * ptr; } originalFunc;
         #if defined( _GNU_SOURCE )
                 if ( version ) {
                         originalFunc.ptr = dlvsym( library, symbol, version );
                 } else {
                         originalFunc.ptr = dlsym( library, symbol );
+                }
+        if ( version ) {
+                originalFunc.ptr = dlvsym( library, symbol, version );
+        } else {
+                originalFunc.ptr = dlsym( library, symbol );
+        } // if
         #else
                 originalFunc.ptr = dlsym( library, symbol );
+        originalFunc.ptr = dlsym( library, symbol );
         #endif // _GNU_SOURCE
         error = dlerror();
         if ( error ) abort( "interpose_symbol : internal error, %s\n", error );
+        if ( ! originalFunc.ptr ) {                                                     // == nullptr
+                abort( "interpose_symbol : internal error, %s\n", dlerror() );
+        } // if
         return originalFunc.fptr;
+}
 static generic_fptr_t interpose_symbol( const char symbol[], const char version[] ) {
+        const char * error;
+        static void * library;
+        static void * pthread_library;
+        if ( ! library ) {
+                #if defined( RTLD_NEXT )
+                        library = RTLD_NEXT;
+                #else
+                        // missing RTLD_NEXT => must hard-code library name, assuming libstdc++
+                        library = dlopen( "libc.so.6", RTLD_LAZY );
+                        error = dlerror();
+                        if ( error ) {
+                                abort( "interpose_symbol : failed to open libc, %s\n", error );
+                        }
+                #endif
+        void * library;
+        #if defined( RTLD_NEXT )
+        library = RTLD_NEXT;
+        #else
+        // missing RTLD_NEXT => must hard-code library name, assuming libstdc++
+        library = dlopen( "libc.so.6", RTLD_LAZY );
+        if ( ! library ) {                                                                      // == nullptr
+                abort( "interpose_symbol : failed to open libc, %s\n", dlerror() );
         } // if
+        if ( ! pthread_library ) {
+                #if defined( RTLD_NEXT )
+                        pthread_library = RTLD_NEXT;
+                #else
+                        // missing RTLD_NEXT => must hard-code library name, assuming libstdc++
+                        pthread_library = dlopen( "libpthread.so", RTLD_LAZY );
+                        error = dlerror();
+                        if ( error ) {
+                                abort( "interpose_symbol : failed to open libpthread, %s\n", error );
+                        }
+                #endif
+        } // if
+        return do_interpose_symbol(library, symbol, version);
+        #endif // RTLD_NEXT
+        return do_interpose_symbol( library, symbol, version );
+}
 …
                 preload_libgcc();
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wdiscarded-qualifiers"
+                #pragma GCC diagnostic push
+                #pragma GCC diagnostic ignored "-Wdiscarded-qualifiers"
                 INTERPOSE_LIBC( abort, version );
                 INTERPOSE_LIBC( exit , version );
 #pragma GCC diagnostic pop
+                #pragma GCC diagnostic pop
                 if(__cfathreadabi_interpose_startup) __cfathreadabi_interpose_startup( do_interpose_symbol );
+                // SKULLDUGGERY: In Ubuntu 22.04, someone augmented signal.h to allow SIGSTKSZ to be "sysconf(_SC_SIGSTKSZ)" in
+                // sigstksz.h, as well as 8192 in sigstack.h. HOWEVER, they forgot to provide a mechanism to tell signal.h to
+                // use sigstack.h rather than sigstksz.h. (I'm not happy.) By undefining _GNU_SOURCE before signal.h and
+                // redefining it afterwards, you can get 8192, but then nothing works correctly inside of signal.h without
+                // _GNU_SOURCE defined.  So what is needed is a way to get signal.h to use sigstack.h WITH _GNU_SOURCE defined.
+                // Basically something is wrong with features.h and its use in signal.h.
+                #undef SIGSTKSZ
+                #define SIGSTKSZ 8192
                 // As a precaution (and necessity), errors that result in termination are delivered on a separate stack because
 …
         va_start( args, fmt );
         __abort( false, fmt, args );
     // CONTROL NEVER REACHES HERE!
+        // CONTROL NEVER REACHES HERE!
         va_end( args );
+}
 void abort( bool signalAbort, const char fmt[], ... ) {
     va_list args;
     va_start( args, fmt );
     __abort( signalAbort, fmt, args );
     // CONTROL NEVER REACHES HERE!
     va_end( args );
+        va_list args;
+        va_start( args, fmt );
+        __abort( signalAbort, fmt, args );
+        // CONTROL NEVER REACHES HERE!
+        va_end( args );
+}

libcfa/src/interpose_thread.cfa

-              r34b4268
+              r24d6572
 //
+#include <stdarg.h>                                                                             // va_start, va_end
+#include <stdio.h>
+#include <string.h>                                                                             // strlen
+// BUG in 32-bit gcc with interpose: fixed in >= gcc-9.5, gcc-10.4, gcc-12.2
+#ifdef __i386__                                                                                 // 32-bit architecture
+#undef _GNU_SOURCE
+#endif // __i386__
 #include <signal.h>
 #include <pthread.h>
+#include <signal.h>
 extern "C" {
 #include <dlfcn.h>                                                                              // dlopen, dlsym
-#include <execinfo.h>                                                                   // backtrace, messages
+}
-#include "bits/debug.hfa"
 #include "bits/defs.hfa"
-#include <assert.h>
 //=============================================================================================
 …
 typedef void (* generic_fptr_t)(void);
 generic_fptr_t interpose_symbol(
+generic_fptr_t libcfa_public interpose_symbol(
         generic_fptr_t (*do_interpose_symbol)( void * library, const char symbol[], const char version[] ),
         const char symbol[],
         const char version[]
 ) libcfa_public {
         const char * error;
+) {
+        void * library;
+        static void * library;
+        if ( ! library ) {
+                #if defined( RTLD_NEXT )
+                        library = RTLD_NEXT;
+                #else
+                        // missing RTLD_NEXT => must hard-code library name, assuming libstdc++
+                        library = dlopen( "libpthread.so", RTLD_LAZY );
+                        error = dlerror();
+                        if ( error ) {
+                                abort( "interpose_symbol : failed to open libpthread, %s\n", error );
+                        }
+                #endif
+        #if defined( RTLD_NEXT )
+        library = RTLD_NEXT;
+        #else
+        // missing RTLD_NEXT => must hard-code library name, assuming libstdc++
+        library = dlopen( "libpthread.so", RTLD_LAZY );
+        if ( ! library ) {                                                                      // == nullptr
+                abort( "interpose_symbol : failed to open libpthread, %s\n", dlerror() );
         } // if
+        #endif // RTLD_NEXT
         return do_interpose_symbol(library, symbol, version);
+        return do_interpose_symbol( library, symbol, version );
+}
 …
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wdiscarded-qualifiers"
                 INTERPOSE( pthread_create , version );
                 INTERPOSE( pthread_join , version );
                 INTERPOSE( pthread_self , version );
                 INTERPOSE( pthread_attr_init , version );
                 INTERPOSE( pthread_attr_destroy , version );
                 INTERPOSE( pthread_attr_setstack , version );
                 INTERPOSE( pthread_attr_getstacksize , version );
                 INTERPOSE( pthread_sigmask , version );
                 INTERPOSE( pthread_sigqueue , version );
                 INTERPOSE( pthread_once , version );
+                INTERPOSE( pthread_create, version );
+                INTERPOSE( pthread_join, version );
+                INTERPOSE( pthread_self, version );
+                INTERPOSE( pthread_attr_init, version );
+                INTERPOSE( pthread_attr_destroy, version );
+                INTERPOSE( pthread_attr_setstack, version );
+                INTERPOSE( pthread_attr_getstacksize, version );
+                INTERPOSE( pthread_sigmask, version );
+                INTERPOSE( pthread_sigqueue, version );
+                INTERPOSE( pthread_once, version );
 #pragma GCC diagnostic pop
+        }

libcfa/src/iostream.cfa

-              r34b4268
+              r24d6572
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Aug 27 15:04:15 2022
 // Update Count     : 1358
+// Last Modified On : Mon Jan  9 09:27:58 2023
+// Update Count     : 1361
 //
 …
                         } /* if */ \
                         if ( ! f.flags.nobsdp || (exp10 < SUFFIXES_START) || (exp10 > SUFFIXES_END) ) { \
                                 len2 = snprintf( &buf[len], size - len, "e%d", exp10 ); \
+                                len2 = snprintf( &buf[len], size - len, "e%d", (int)exp10 /* ambiguity with function exp10 */ ); \
                         } else { \
                                 len2 = snprintf( &buf[len], size - len, "%s", suffixes[(exp10 - SUFFIXES_START) / 3] ); \

libcfa/src/iostream.hfa

-              r34b4268
+              r24d6572
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sun Oct 10 10:02:07 2021
 // Update Count     : 407
+// Last Modified On : Thu Feb  2 11:25:39 2023
+// Update Count     : 410
 //
 …
+trait basic_ostream( ostype & ) {
+forall( ostype & )
+trait basic_ostream {
         // private
         bool sepPrt$( ostype & );                                                       // get separator state (on/off)
 …
 }; // basic_ostream
+trait ostream( ostype & | basic_ostream( ostype ) ) {
+forall( ostype & | basic_ostream( ostype ) )
+trait ostream {
         bool fail( ostype & );                                                          // operation failed?
         void clear( ostype & );
 …
 }; // ostream
+// trait writeable( T ) {
+// forall( T )
+// trait writeable {
 //      forall( ostype & | ostream( ostype ) ) ostype & ?|?( ostype &, T );
 // }; // writeable
+trait writeable( T, ostype & | ostream( ostype ) ) {
+forall( T, ostype & | ostream( ostype ) )
+        trait writeable {
         ostype & ?|?( ostype &, T );
 }; // writeable
 …
+trait basic_istream( istype & ) {
+forall( istype & )
+trait basic_istream {
         // private
         bool getANL$( istype & );                                                       // get scan newline (on/off)
 …
 }; // basic_istream
+trait istream( istype & | basic_istream( istype ) ) {
+forall( istype & | basic_istream( istype ) )
+trait istream {
         bool fail( istype & );
         void clear( istype & );
 …
 }; // istream
+trait readable( T ) {
+forall( T )
+trait readable {
         forall( istype & | istream( istype ) ) istype & ?|?( istype &, T );
 }; // readable

libcfa/src/iterator.hfa

-              r34b4268
+              r24d6572
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Jul  7 08:37:25 2017
 // Update Count     : 10
+// Last Modified On : Thu Feb  2 11:21:50 2023
+// Update Count     : 11
 //
 …
 // An iterator can be used to traverse a data structure.
+trait iterator( iterator_type, elt_type ) {
+forall( iterator_type, elt_type )
+trait iterator {
         // point to the next element
 //      iterator_type ?++( iterator_type & );
 …
 };
+trait iterator_for( iterator_type, collection_type, elt_type | iterator( iterator_type, elt_type ) ) {
+forall( iterator_type, collection_type, elt_type | iterator( iterator_type, elt_type ) )
+        trait iterator_for {
 //      [ iterator_type begin, iterator_type end ] get_iterators( collection_type );
         iterator_type begin( collection_type );

libcfa/src/limits.cfa

-              r34b4268
+              r24d6572
 // Created On       : Wed Apr  6 18:06:52 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Mar  1 16:22:51 2018
 // Update Count     : 74
+// Last Modified On : Fri Feb 17 12:25:39 2023
+// Update Count     : 87
 //
 #include <limits.h>
 #include <float.h>
-#define __USE_GNU                                                                               // get M_* constants
 #include <math.h>
 #include <complex.h>

libcfa/src/math.trait.hfa

-              r34b4268
+              r24d6572
 // Created On       : Fri Jul 16 15:40:52 2021
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Tue Jul 20 17:47:19 2021
 // Update Count     : 19
+// Last Modified On : Thu Feb  2 11:36:56 2023
+// Update Count     : 20
 //
 #pragma once
+trait Not( U ) {
+forall( U )
+trait Not {
         void ?{}( U &, zero_t );
         int !?( U );
 }; // Not
+trait Equality( T | Not( T ) ) {
+forall( T | Not( T ) )
+trait Equality {
         int ?==?( T, T );
         int ?!=?( T, T );
 }; // Equality
+trait Relational( U | Equality( U ) ) {
+forall( U | Equality( U ) )
+trait Relational {
         int ?<?( U, U );
         int ?<=?( U, U );
 …
 }; // Relational
+trait Signed( T ) {
+forall ( T )
+trait Signed {
         T +?( T );
         T -?( T );
 …
 }; // Signed
+trait Additive( U | Signed( U ) ) {
+forall( U | Signed( U ) )
+trait Additive {
         U ?+?( U, U );
         U ?-?( U, U );
 …
 }; // Additive
+trait Incdec( T | Additive( T ) ) {
+forall( T | Additive( T ) )
+trait Incdec {
         void ?{}( T &, one_t );
         // T ?++( T & );
 …
 }; // Incdec
+trait Multiplicative( U | Incdec( U ) ) {
+forall( U | Incdec( U ) )
+trait Multiplicative {
         U ?*?( U, U );
         U ?/?( U, U );
 …
 }; // Multiplicative
+trait Arithmetic( T | Relational( T ) | Multiplicative( T ) ) {
+forall( T | Relational( T ) | Multiplicative( T ) )
+trait Arithmetic {
 }; // Arithmetic

libcfa/src/stdlib.cfa

-              r34b4268
+              r24d6572
 // Created On       : Thu Jan 28 17:10:29 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Dec  9 15:11:30 2022
 // Update Count     : 631
+// Last Modified On : Thu Feb 16 16:31:34 2023
+// Update Count     : 633
 //
 …
 //---------------------------------------
-#define _XOPEN_SOURCE 600                                                               // posix_memalign, *rand48
 #include <string.h>                                                                             // memcpy, memset
 //#include <math.h>                                                                             // fabsf, fabs, fabsl

libcfa/src/stdlib.hfa

-              r34b4268
+              r24d6572
 // Created On       : Thu Jan 28 17:12:35 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sun Dec 11 18:25:53 2022
 // Update Count     : 765
+// Last Modified On : Thu Feb  2 11:30:04 2023
+// Update Count     : 766
 //
 …
         char random( void ) { return (unsigned long int)random(); }
         char random( char u ) { return random( (unsigned long int)u ); } // [0,u)
+        char random( char u ) { return (unsigned long int)random( (unsigned long int)u ); } // [0,u)
         char random( char l, char u ) { return random( (unsigned long int)l, (unsigned long int)u ); } // [l,u)
         int random( void ) { return (long int)random(); }
         int random( int u ) { return random( (long int)u ); } // [0,u]
+        int random( int u ) { return (long int)random( (long int)u ); } // [0,u]
         int random( int l, int u ) { return random( (long int)l, (long int)u ); } // [l,u)
         unsigned int random( void ) { return (unsigned long int)random(); }
         unsigned int random( unsigned int u ) { return random( (unsigned long int)u ); } // [0,u]
+        unsigned int random( unsigned int u ) { return (unsigned long int)random( (unsigned long int)u ); } // [0,u]
         unsigned int random( unsigned int l, unsigned int u ) { return random( (unsigned long int)l, (unsigned long int)u ); } // [l,u)
 } // distribution
 …
 //   calls( sprng );
+trait basic_prng( PRNG &, R ) {
+forall( PRNG &, R )
+trait basic_prng {
         void set_seed( PRNG & prng, R seed );                           // set seed
         R get_seed( PRNG & prng );                                                      // get seed

libcfa/src/vec/vec.hfa

-              r34b4268
+              r24d6572
 #include <math.hfa>
+trait fromint(T) {
+forall(T)
+trait fromint {
     void ?{}(T&, int);
 };
+trait zeroinit(T) {
+forall(T)
+trait zeroinit {
     void ?{}(T&, zero_t);
 };
+trait zero_assign(T) {
+forall(T)
+trait zero_assign {
     T ?=?(T&, zero_t);
 };
+trait subtract(T) {
+forall(T)
+trait subtract {
     T ?-?(T, T);
 };
+trait negate(T) {
+forall(T)
+trait negate {
     T -?(T);
 };
+trait add(T) {
+forall(T)
+trait add {
     T ?+?(T, T);
 };
+trait multiply(T) {
+forall(T)
+trait multiply {
     T ?*?(T, T);
 };
+trait divide(T) {
+forall(T)
+trait divide {
     T ?/?(T, T);
 };
+trait lessthan(T) {
+forall(T)
+trait lessthan {
     int ?<?(T, T);
 };
+trait equality(T) {
+forall(T)
+trait equality {
     int ?==?(T, T);
 };
+trait sqrt(T) {
+forall(T)
+trait sqrt {
     T sqrt(T);
 };

src/AST/Attribute.hpp

r34b4268	r24d6572
27	27	class Expr;
28	28
	29	/// An entry in an attribute list: `__attribute__(( ... ))`
29	30	class Attribute final : public Node {
30	31	public:

src/AST/Convert.cpp

-              r34b4268
+              r24d6572
                 auto stmt = new SuspendStmt();
                 stmt->then   = get<CompoundStmt>().accept1( node->then   );
                 switch(node->type) {
+                switch (node->kind) {
                         case ast::SuspendStmt::None     : stmt->type = SuspendStmt::None     ; break;
                         case ast::SuspendStmt::Coroutine: stmt->type = SuspendStmt::Coroutine; break;
 …
+                }
                 return stmtPostamble( stmt, node );
+        }
+    const ast::WhenClause * visit( const ast::WhenClause * node ) override final {
+                // There is no old-AST WhenClause, so this should never be called.
+                assert( !node );
+                return nullptr;
+        }
 …
                 for ( auto clause : node->clauses ) {
                         stmt->clauses.push_back({{
                                         get<Expression>().accept1( clause->target_func ),
+                                        get<Expression>().accept1( clause->target ),
                                         get<Expression>().acceptL( clause->target_args ),
                                 },
                                 get<Statement>().accept1( clause->stmt ),
                                 get<Expression>().accept1( clause->cond ),
+                                get<Expression>().accept1( clause->when_cond ),
                         });
+                }
 …
         const ast::WaitForClause * visit( const ast::WaitForClause * node ) override final {
                 // There is no old-AST WaitForClause, so this should never be called.
+                assert( !node );
+                return nullptr;
+        }
+    const ast::Stmt * visit( const ast::WaitUntilStmt * node ) override final {
+        // There is no old-AST WaitUntilStmt, so this should never be called.
                 assert( !node );
                 return nullptr;
 …
                         GET_ACCEPT_V(attributes, Attribute),
                         { old->get_funcSpec().val },
                         old->type->isVarArgs
+                        (old->type->isVarArgs) ? ast::VariableArgs : ast::FixedArgs
                 };
 …
                         GET_ACCEPT_1(else_, Stmt),
                         GET_ACCEPT_V(initialization, Stmt),
                         old->isDoWhile,
+                        (old->isDoWhile) ? ast::DoWhile : ast::While,
                         GET_LABELS_V(old->labels)
                 );
 …
         virtual void visit( const SuspendStmt * old ) override final {
                 if ( inCache( old ) ) return;
                 ast::SuspendStmt::Type type;
+                ast::SuspendStmt::Kind type;
                 switch (old->type) {
                         case SuspendStmt::Coroutine: type = ast::SuspendStmt::Coroutine; break;
 …
                         auto clause = new ast::WaitForClause( old->location );
                         clause->target_func = GET_ACCEPT_1(clauses[i].target.function, Expr);
+                        clause->target = GET_ACCEPT_1(clauses[i].target.function, Expr);
                         clause->target_args = GET_ACCEPT_V(clauses[i].target.arguments, Expr);
                         clause->stmt = GET_ACCEPT_1(clauses[i].statement, Stmt);
                         clause->cond = GET_ACCEPT_1(clauses[i].condition, Expr);
+                        clause->when_cond = GET_ACCEPT_1(clauses[i].condition, Expr);
                         stmt->clauses.push_back( clause );

src/AST/Create.cpp

r34b4268	r24d6572
20	20	#include "AST/Decl.hpp"
21	21	#include "AST/Type.hpp"
	22	#include "Common/Iterate.hpp"
22	23
23	24	namespace ast {

src/AST/Decl.cpp

-              r34b4268
+              r24d6572
 #include <unordered_map>
 #include "Common/utility.h"
+#include "Common/Eval.h"       // for eval
 #include "Fwd.hpp"             // for UniqueId
 …
         std::vector<ptr<DeclWithType>>&& params, std::vector<ptr<DeclWithType>>&& returns,
         CompoundStmt * stmts, Storage::Classes storage, Linkage::Spec linkage,
         std::vector<ptr<Attribute>>&& attrs, Function::Specs fs, bool isVarArgs)
+        std::vector<ptr<Attribute>>&& attrs, Function::Specs fs, ArgumentFlag isVarArgs )
 : DeclWithType( loc, name, storage, linkage, std::move(attrs), fs ),
         type_params(std::move(forall)), assertions(),
         params(std::move(params)), returns(std::move(returns)), stmts( stmts ) {
         FunctionType * ftype = new FunctionType(static_cast<ArgumentFlag>(isVarArgs));
+        FunctionType * ftype = new FunctionType( isVarArgs );
         for (auto & param : this->params) {
                 ftype->params.emplace_back(param->get_type());
 …
         std::vector<ptr<DeclWithType>>&& params, std::vector<ptr<DeclWithType>>&& returns,
         CompoundStmt * stmts, Storage::Classes storage, Linkage::Spec linkage,
         std::vector<ptr<Attribute>>&& attrs, Function::Specs fs, bool isVarArgs)
+        std::vector<ptr<Attribute>>&& attrs, Function::Specs fs, ArgumentFlag isVarArgs )
 : DeclWithType( location, name, storage, linkage, std::move(attrs), fs ),
                 type_params( std::move( forall) ), assertions( std::move( assertions ) ),
                 params( std::move(params) ), returns( std::move(returns) ),
                 type( nullptr ), stmts( stmts ) {
         FunctionType * type = new FunctionType( (isVarArgs) ? VariableArgs : FixedArgs );
+        FunctionType * type = new FunctionType( isVarArgs );
         for ( auto & param : this->params ) {
                 type->params.emplace_back( param->get_type() );

src/AST/Decl.hpp

-              r34b4268
+              r24d6572
 // Created On       : Thu May 9 10:00:00 2019
 // Last Modified By : Andrew Beach
 // Last Modified On : Thu Nov 24  9:44:00 2022
 // Update Count     : 34
+// Last Modified On : Wed Apr  5 10:42:00 2023
+// Update Count     : 35
 //
 …
 };
+/// Function variable arguments flag
+enum ArgumentFlag { FixedArgs, VariableArgs };
 /// Object declaration `int foo()`
 class FunctionDecl : public DeclWithType {
 …
                 std::vector<ptr<DeclWithType>>&& params, std::vector<ptr<DeclWithType>>&& returns,
                 CompoundStmt * stmts, Storage::Classes storage = {}, Linkage::Spec linkage = Linkage::Cforall,
                 std::vector<ptr<Attribute>>&& attrs = {}, Function::Specs fs = {}, bool isVarArgs = false);
+                std::vector<ptr<Attribute>>&& attrs = {}, Function::Specs fs = {}, ArgumentFlag isVarArgs = FixedArgs );
         FunctionDecl( const CodeLocation & location, const std::string & name,
 …
                 std::vector<ptr<DeclWithType>>&& params, std::vector<ptr<DeclWithType>>&& returns,
                 CompoundStmt * stmts, Storage::Classes storage = {}, Linkage::Spec linkage = Linkage::Cforall,
                 std::vector<ptr<Attribute>>&& attrs = {}, Function::Specs fs = {}, bool isVarArgs = false);
+                std::vector<ptr<Attribute>>&& attrs = {}, Function::Specs fs = {}, ArgumentFlag isVarArgs = FixedArgs );
         const Type * get_type() const override;
 …
 public:
         bool isTyped; // isTyped indicated if the enum has a declaration like:
         // enum (type_optional) Name {...}
+        // enum (type_optional) Name {...}
         ptr<Type> base; // if isTyped == true && base.get() == nullptr, it is a "void" type enum
         enum class EnumHiding { Visible, Hide } hide;
 …
 };
+/// Assembly declaration: `asm ... ( "..." : ... )`
 class AsmDecl : public Decl {
 public:

src/AST/Expr.cpp

r34b4268	r24d6572
30	30	#include "Common/SemanticError.h"
31	31	#include "GenPoly/Lvalue.h" // for referencesPermissable
32		#include "ResolvExpr/~~typeops.h"~~ // for extractResultType
	32	#include "ResolvExpr/Unify.h" // for extractResultType
33	33	#include "Tuples/Tuples.h" // for makeTupleType
34	34

src/AST/Expr.hpp

-              r34b4268
+              r24d6572
 };
+/// A name qualified by a namespace or type.
 class QualifiedNameExpr final : public Expr {
 public:
 …
         std::string name;
         QualifiedNameExpr( const CodeLocation & loc, const Decl * d, const std::string & n )
+        QualifiedNameExpr( const CodeLocation & loc, const Decl * d, const std::string & n )
         : Expr( loc ), type_decl( d ), name( n ) {}
 …
 };
+/// A name that refers to a generic dimension parameter.
 class DimensionExpr final : public Expr {
 public:
 …
 };
+}

src/AST/Fwd.hpp

-              r34b4268
+              r24d6572
 #pragma once
+template<typename> struct bitfield;
 #include "AST/Node.hpp"
 …
 class FinallyClause;
 class SuspendStmt;
+class WhenClause;
 class WaitForStmt;
 class WaitForClause;
+class WaitUntilStmt;
 class WithStmt;
 class DeclStmt;
 …
 class TranslationGlobal;
+// For the following types, only use the using type.
+namespace CV {
+        struct qualifier_flags;
+        using Qualifiers = bitfield<qualifier_flags>;
+}
+namespace Function {
+        struct spec_flags;
+        using Specs = bitfield<spec_flags>;
+}
+namespace Storage {
+        struct class_flags;
+        using Classes = bitfield<class_flags>;
+}
+namespace Linkage {
+        struct spec_flags;
+        using Spec = bitfield<spec_flags>;
+}
+}

src/AST/Init.hpp

r34b4268	r24d6572
117	117	ptr<Init> init;
118	118
119		ConstructorInit(
	119	ConstructorInit(
120	120	const CodeLocation & loc, const Stmt * ctor, const Stmt * dtor, const Init * init )
121	121	: Init( loc, MaybeConstruct ), ctor( ctor ), dtor( dtor ), init( init ) {}

src/AST/Inspect.cpp

-              r34b4268
+              r24d6572
 // Created On       : Fri Jun 24 13:16:31 2022
 // Last Modified By : Andrew Beach
 // Last Modified On : Mon Oct  3 11:04:00 2022
 // Update Count     : 3
+// Last Modified On : Fri Apr 14 15:09:00 2023
+// Update Count     : 4
 //
 …
+}
+bool isUnnamedBitfield( const ast::ObjectDecl * obj ) {
+        return obj && obj->name.empty() && obj->bitfieldWidth;
+}
 } // namespace ast

src/AST/Inspect.hpp

-              r34b4268
+              r24d6572
 // Created On       : Fri Jun 24 13:16:31 2022
 // Last Modified By : Andrew Beach
 // Last Modified On : Thr Sep 22 13:44:00 2022
 // Update Count     : 2
+// Last Modified On : Fri Apr 14 15:09:00 2023
+// Update Count     : 3
 //
 …
 const ApplicationExpr * isIntrinsicCallExpr( const Expr * expr );
+/// Returns true if obj's name is the empty string and it has a bitfield width.
+bool isUnnamedBitfield( const ObjectDecl * obj );
+}

src/AST/Node.cpp

-              r34b4268
+              r24d6572
 template class ast::ptr_base< ast::FinallyClause, ast::Node::ref_type::weak >;
 template class ast::ptr_base< ast::FinallyClause, ast::Node::ref_type::strong >;
+template class ast::ptr_base< ast::WhenClause, ast::Node::ref_type::weak >;
+template class ast::ptr_base< ast::WhenClause, ast::Node::ref_type::strong >;
 template class ast::ptr_base< ast::WaitForStmt, ast::Node::ref_type::weak >;
 template class ast::ptr_base< ast::WaitForStmt, ast::Node::ref_type::strong >;
 template class ast::ptr_base< ast::WaitForClause, ast::Node::ref_type::weak >;
 template class ast::ptr_base< ast::WaitForClause, ast::Node::ref_type::strong >;
+template class ast::ptr_base< ast::WaitUntilStmt, ast::Node::ref_type::weak >;
+template class ast::ptr_base< ast::WaitUntilStmt, ast::Node::ref_type::strong >;
 template class ast::ptr_base< ast::WithStmt, ast::Node::ref_type::weak >;
 template class ast::ptr_base< ast::WithStmt, ast::Node::ref_type::strong >;

src/AST/Node.hpp

-              r34b4268
+              r24d6572
 #include <cstddef>     // for nullptr_t
 #include <iosfwd>
-#include <type_traits> // for remove_reference
 #include "Common/ErrorObjects.h"  // for SemanticErrorException
 …
         Node(const Node&) : strong_count(0), weak_count(0) {}
         Node(Node&&) : strong_count(0), weak_count(0) {}
         Node& operator= (const Node&) = delete;
         Node& operator= (Node&&) = delete;
+        Node& operator=(const Node&) = delete;
+        Node& operator=(Node&&) = delete;
         virtual ~Node() {}

src/AST/ParseNode.hpp

r34b4268	r24d6572
40	40	template<typename node_t>
41	41	friend node_t * mutate(const node_t * node);
	42	template<typename node_t>
	43	friend node_t * shallowCopy(const node_t * node);
42	44	};
43	45

src/AST/Pass.hpp

-              r34b4268
+              r24d6572
 //
 // Other Special Members:
+// | beginScope            - A method with no parameters or return value, called each time the
+//                           visitor enters a block.
+// | endScope              - A method with no parameters or return value, called each time the
+//                           visitor leaves a block.
 // | result                - Either a method that takes no parameters or a field. If a method (or
 //                           callable field) get_result calls it, otherwise the value is returned.
 …
+        {
                 // After the pass is constructed, check if it wants the have a pointer to the wrapping visitor
                 type * const * visitor = __pass::visitor(core, 0);
                 if(visitor) {
+                type * const * visitor = __pass::visitor( core, 0 );
+                if ( visitor ) {
                         *const_cast<type **>( visitor ) = this;
+                }
 …
         /// If the core defines a result, call it if possible, otherwise return it.
         inline auto get_result() -> decltype( __pass::get_result( core, '0' ) ) {
                 return __pass::get_result( core, '0' );
+        inline auto get_result() -> decltype( __pass::result::get( core, '0' ) ) {
+                return __pass::result::get( core, '0' );
+        }
 …
         const ast::FinallyClause *    visit( const ast::FinallyClause        * ) override final;
         const ast::Stmt *             visit( const ast::SuspendStmt          * ) override final;
+    const ast::WhenClause *       visit( const ast::WhenClause           * ) override final;
         const ast::Stmt *             visit( const ast::WaitForStmt          * ) override final;
         const ast::WaitForClause *    visit( const ast::WaitForClause        * ) override final;
+    const ast::Stmt *             visit( const ast::WaitUntilStmt        * ) override final;
         const ast::Decl *             visit( const ast::WithStmt             * ) override final;
         const ast::NullStmt *         visit( const ast::NullStmt             * ) override final;

src/AST/Pass.impl.hpp

-              r34b4268
+              r24d6572
 #include <unordered_map>
+#include "AST/Copy.hpp"
 #include "AST/TranslationUnit.hpp"
 #include "AST/TypeSubstitution.hpp"
 …
 #ifdef PEDANTIC_PASS_ASSERT
 #define __pedantic_pass_assert(...) assert (__VA_ARGS__)
+#define __pedantic_pass_assert(...) assert(__VA_ARGS__)
 #define __pedantic_pass_assertf(...) assertf(__VA_ARGS__)
 #else
 …
                         return !new_val.empty();
+                }
+        }
-        template< typename node_t >
-        template< typename object_t, typename super_t, typename field_t >
-        void __pass::result1< node_t >::apply( object_t * object, field_t super_t::* field ) {
-                object->*field = value;
+        }
 …
                 return {true, compound};
+        }
-        template< template <class...> class container_t >
-        template< typename object_t, typename super_t, typename field_t >
-        void __pass::resultNstmt<container_t>::apply(object_t * object, field_t super_t::* field) {
-                auto & container = object->*field;
-                __pedantic_pass_assert( container.size() <= values.size() );
-                auto cit = enumerate(container).begin();
-                container_t<ptr<Stmt>> nvals;
-                for (delta & d : values) {
-                        if ( d.is_old ) {
-                                __pedantic_pass_assert( cit.idx <= d.old_idx );
-                                std::advance( cit, d.old_idx - cit.idx );
-                                nvals.push_back( std::move( (*cit).val) );
-                        } else {
-                                nvals.push_back( std::move(d.new_val) );
+                        }
+                }
-                container = std::move(nvals);
+        }
-        template< template <class...> class container_t >
-        template< template <class...> class incontainer_t >
-        void __pass::resultNstmt< container_t >::take_all( incontainer_t<ptr<Stmt>> * stmts ) {
-                if (!stmts || stmts->empty()) return;
-                std::transform(stmts->begin(), stmts->end(), std::back_inserter( values ),
-                        [](ast::ptr<ast::Stmt>& stmt) -> delta {
-                                return delta( stmt.release(), -1, false );
-                        });
-                stmts->clear();
-                differs = true;
+        }
-        template< template<class...> class container_t >
-        template< template<class...> class incontainer_t >
-        void __pass::resultNstmt< container_t >::take_all( incontainer_t<ptr<Decl>> * decls ) {
-                if (!decls || decls->empty()) return;
-                std::transform(decls->begin(), decls->end(), std::back_inserter( values ),
-                        [](ast::ptr<ast::Decl>& decl) -> delta {
-                                auto loc = decl->location;
-                                auto stmt = new DeclStmt( loc, decl.release() );
-                                return delta( stmt, -1, false );
-                        });
-                decls->clear();
-                differs = true;
+        }
 …
                 return new_kids;
+        }
-        template< template <class...> class container_t, typename node_t >
-        template< typename object_t, typename super_t, typename field_t >
-        void __pass::resultN<container_t, node_t>::apply(object_t * object, field_t super_t::* field) {
-                auto & container = object->*field;
-                __pedantic_pass_assert( container.size() == values.size() );
-                for(size_t i = 0; i < container.size(); i++) {
-                        // Take all the elements that are different in 'values'
-                        // and swap them into 'container'
-                        if( values[i] != nullptr ) swap(container[i], values[i]);
+                }
-                // Now the original containers should still have the unchanged values
-                // but also contain the new values
+        }
 …
                         if ( enterScope ) {
                                 __pass::symtab::enter(core, 0);
-                                __pass::scope::enter(core, 0);
+                        }
                 }, [this, leaveScope = !this->atFunctionTop]() {
                         if ( leaveScope ) {
                                 __pass::symtab::leave(core, 0);
-                                __pass::scope::leave(core, 0);
+                        }
                 });
 …
 //--------------------------------------------------------------------------
+// WhenClause
+template< typename core_t >
+const ast::WhenClause * ast::Pass< core_t >::visit( const ast::WhenClause * node ) {
+        VISIT_START( node );
+        if ( __visit_children() ) {
+                maybe_accept( node, &WhenClause::target );
+                maybe_accept( node, &WhenClause::stmt );
+                maybe_accept( node, &WhenClause::when_cond );
+        }
+        VISIT_END( WhenClause, node );
+}
+//--------------------------------------------------------------------------
 // WaitForStmt
 template< typename core_t >
 …
         if ( __visit_children() ) {
                 maybe_accept( node, &WaitForClause::target_func );
+                maybe_accept( node, &WaitForClause::target );
                 maybe_accept( node, &WaitForClause::target_args );
                 maybe_accept( node, &WaitForClause::stmt );
                 maybe_accept( node, &WaitForClause::cond );
+                maybe_accept( node, &WaitForClause::when_cond );
+        }
         VISIT_END( WaitForClause, node );
+}
+//--------------------------------------------------------------------------
+// WaitUntilStmt
+template< typename core_t >
+const ast::Stmt * ast::Pass< core_t >::visit( const ast::WaitUntilStmt * node ) {
+        VISIT_START( node );
+        if ( __visit_children() ) {
+                maybe_accept( node, &WaitUntilStmt::clauses );
+                maybe_accept( node, &WaitUntilStmt::timeout_time );
+                maybe_accept( node, &WaitUntilStmt::timeout_stmt );
+                maybe_accept( node, &WaitUntilStmt::timeout_cond );
+                maybe_accept( node, &WaitUntilStmt::else_stmt );
+                maybe_accept( node, &WaitUntilStmt::else_cond );
+        }
+        VISIT_END( Stmt, node );
+}
 …
         if ( __visit_children() ) {
                 maybe_accept( node, &TupleType::types );
-                maybe_accept( node, &TupleType::members );
+        }
 …
+}
+#undef __pedantic_pass_assertf
+#undef __pedantic_pass_assert
 #undef VISIT_START
 #undef VISIT_END

src/AST/Pass.proto.hpp

-              r34b4268
+              r24d6572
 // IWYU pragma: private, include "Pass.hpp"
+#include "Common/Iterate.hpp"
 #include "Common/Stats/Heap.h"
 namespace ast {
+template<typename core_t>
+class Pass;
+class TranslationUnit;
+struct PureVisitor;
+template<typename node_t>
+node_t * deepCopy( const node_t * localRoot );
+namespace __pass {
+        typedef std::function<void( void * )> cleanup_func_t;
+        typedef std::function<void( cleanup_func_t, void * )> at_cleanup_t;
+        // boolean reference that may be null
+        // either refers to a boolean value or is null and returns true
+        class bool_ref {
+        public:
+                bool_ref() = default;
+                ~bool_ref() = default;
+                operator bool() { return m_ref ? *m_ref : true; }
+                bool operator=( bool val ) { assert(m_ref); return *m_ref = val; }
+        private:
+                friend class visit_children_guard;
+                bool * set( bool * val ) {
+                        bool * prev = m_ref;
+                        m_ref = val;
+                        return prev;
+                }
+                bool * m_ref = nullptr;
+        template<typename core_t> class Pass;
+        class TranslationUnit;
+        struct PureVisitor;
+        template<typename node_t> node_t * deepCopy( const node_t * );
+}
+#ifdef PEDANTIC_PASS_ASSERT
+#define __pedantic_pass_assert(...) assert(__VA_ARGS__)
+#define __pedantic_pass_assertf(...) assertf(__VA_ARGS__)
+#else
+#define __pedantic_pass_assert(...)
+#define __pedantic_pass_assertf(...)
+#endif
+namespace ast::__pass {
+typedef std::function<void( void * )> cleanup_func_t;
+typedef std::function<void( cleanup_func_t, void * )> at_cleanup_t;
+// boolean reference that may be null
+// either refers to a boolean value or is null and returns true
+class bool_ref {
+public:
+        bool_ref() = default;
+        ~bool_ref() = default;
+        operator bool() { return m_ref ? *m_ref : true; }
+        bool operator=( bool val ) { assert(m_ref); return *m_ref = val; }
+private:
+        friend class visit_children_guard;
+        bool * set( bool * val ) {
+                bool * prev = m_ref;
+                m_ref = val;
+                return prev;
+        }
+        bool * m_ref = nullptr;
+};
+// Implementation of the guard value
+// Created inside the visit scope
+class guard_value {
+public:
+        /// Push onto the cleanup
+        guard_value( at_cleanup_t * at_cleanup ) {
+                if( at_cleanup ) {
+                        *at_cleanup = [this]( cleanup_func_t && func, void* val ) {
+                                push( std::move( func ), val );
+                        };
+                }
+        }
+        ~guard_value() {
+                while( !cleanups.empty() ) {
+                        auto& cleanup = cleanups.top();
+                        cleanup.func( cleanup.val );
+                        cleanups.pop();
+                }
+        }
+        void push( cleanup_func_t && func, void* val ) {
+                cleanups.emplace( std::move(func), val );
+        }
+private:
+        struct cleanup_t {
+                cleanup_func_t func;
+                void * val;
+                cleanup_t( cleanup_func_t&& func, void * val ) : func(func), val(val) {}
         };
+        // Implementation of the guard value
+        // Created inside the visit scope
+        class guard_value {
+        public:
+                /// Push onto the cleanup
+                guard_value( at_cleanup_t * at_cleanup ) {
+                        if( at_cleanup ) {
+                                *at_cleanup = [this]( cleanup_func_t && func, void* val ) {
+                                        push( std::move( func ), val );
+                                };
+        std::stack< cleanup_t, std::vector<cleanup_t> > cleanups;
+};
+// Guard structure implementation for whether or not children should be visited
+class visit_children_guard {
+public:
+        visit_children_guard( bool_ref * ref )
+                : m_val ( true )
+                , m_prev( ref ? ref->set( &m_val ) : nullptr )
+                , m_ref ( ref )
+        {}
+        ~visit_children_guard() {
+                if( m_ref ) {
+                        m_ref->set( m_prev );
+                }
+        }
+        operator bool() { return m_val; }
+private:
+        bool       m_val;
+        bool     * m_prev;
+        bool_ref * m_ref;
+};
+/// "Short hand" to check if this is a valid previsit function
+/// Mostly used to make the static_assert look (and print) prettier
+template<typename core_t, typename node_t>
+struct is_valid_previsit {
+        using ret_t = decltype( std::declval<core_t*>()->previsit( std::declval<const node_t *>() ) );
+        static constexpr bool value = std::is_void< ret_t >::value ||
+                std::is_base_of<const node_t, typename std::remove_pointer<ret_t>::type >::value;
+};
+/// The result is a single node.
+template< typename node_t >
+struct result1 {
+        bool differs = false;
+        const node_t * value = nullptr;
+        template< typename object_t, typename super_t, typename field_t >
+        void apply( object_t * object, field_t super_t::* field ) {
+                object->*field = value;
+        }
+};
+/// The result is a container of statements.
+template< template<class...> class container_t >
+struct resultNstmt {
+        /// The delta/change on a single node.
+        struct delta {
+                ptr<Stmt> new_val;
+                ssize_t old_idx;
+                bool is_old;
+                delta(const Stmt * s, ssize_t i, bool old) :
+                        new_val(s), old_idx(i), is_old(old) {}
+        };
+        bool differs = false;
+        container_t< delta > values;
+        template< typename object_t, typename super_t, typename field_t >
+        void apply( object_t * object, field_t super_t::* field ) {
+                field_t & container = object->*field;
+                __pedantic_pass_assert( container.size() <= values.size() );
+                auto cit = enumerate(container).begin();
+                container_t<ptr<Stmt>> nvals;
+                for ( delta & d : values ) {
+                        if ( d.is_old ) {
+                                __pedantic_pass_assert( cit.idx <= d.old_idx );
+                                std::advance( cit, d.old_idx - cit.idx );
+                                nvals.push_back( std::move( (*cit).val ) );
+                        } else {
+                                nvals.push_back( std::move( d.new_val ) );
+                        }
+                }
+                ~guard_value() {
+                        while( !cleanups.empty() ) {
+                                auto& cleanup = cleanups.top();
+                                cleanup.func( cleanup.val );
+                                cleanups.pop();
+                        }
+                }
+                void push( cleanup_func_t && func, void* val ) {
+                        cleanups.emplace( std::move(func), val );
+                }
+        private:
+                struct cleanup_t {
+                        cleanup_func_t func;
+                        void * val;
+                        cleanup_t( cleanup_func_t&& func, void * val ) : func(func), val(val) {}
+                };
+                std::stack< cleanup_t, std::vector<cleanup_t> > cleanups;
+        };
+        // Guard structure implementation for whether or not children should be visited
+        class visit_children_guard {
+        public:
+                visit_children_guard( bool_ref * ref )
+                        : m_val ( true )
+                        , m_prev( ref ? ref->set( &m_val ) : nullptr )
+                        , m_ref ( ref )
+                {}
+                ~visit_children_guard() {
+                        if( m_ref ) {
+                                m_ref->set( m_prev );
+                        }
+                }
+                operator bool() { return m_val; }
+        private:
+                bool       m_val;
+                bool     * m_prev;
+                bool_ref * m_ref;
+        };
+        /// "Short hand" to check if this is a valid previsit function
+        /// Mostly used to make the static_assert look (and print) prettier
+                container = std::move(nvals);
+        }
+        template< template<class...> class incontainer_t >
+        void take_all( incontainer_t<ptr<Stmt>> * stmts ) {
+                if ( !stmts || stmts->empty() ) return;
+                std::transform( stmts->begin(), stmts->end(), std::back_inserter( values ),
+                        [](ast::ptr<ast::Stmt>& stmt) -> delta {
+                                return delta( stmt.release(), -1, false );
+                        });
+                stmts->clear();
+                differs = true;
+        }
+        template< template<class...> class incontainer_t >
+        void take_all( incontainer_t<ptr<Decl>> * decls ) {
+                if ( !decls || decls->empty() ) return;
+                std::transform( decls->begin(), decls->end(), std::back_inserter( values ),
+                        [](ast::ptr<ast::Decl>& decl) -> delta {
+                                ast::Decl const * d = decl.release();
+                                return delta( new DeclStmt( d->location, d ), -1, false );
+                        });
+                decls->clear();
+                differs = true;
+        }
+};
+/// The result is a container of nodes.
+template< template<class...> class container_t, typename node_t >
+struct resultN {
+        bool differs = false;
+        container_t<ptr<node_t>> values;
+        template< typename object_t, typename super_t, typename field_t >
+        void apply( object_t * object, field_t super_t::* field ) {
+                field_t & container = object->*field;
+                __pedantic_pass_assert( container.size() == values.size() );
+                for ( size_t i = 0; i < container.size(); ++i ) {
+                        // Take all the elements that are different in 'values'
+                        // and swap them into 'container'
+                        if ( values[i] != nullptr ) swap(container[i], values[i]);
+                }
+                // Now the original containers should still have the unchanged values
+                // but also contain the new values.
+        }
+};
+/// Used by previsit implementation
+/// We need to reassign the result to 'node', unless the function
+/// returns void, then we just leave 'node' unchanged
+template<bool is_void>
+struct __assign;
+template<>
+struct __assign<true> {
         template<typename core_t, typename node_t>
+        struct is_valid_previsit {
+                using ret_t = decltype( std::declval<core_t*>()->previsit( std::declval<const node_t *>() ) );
+                static constexpr bool value = std::is_void< ret_t >::value ||
+                        std::is_base_of<const node_t, typename std::remove_pointer<ret_t>::type >::value;
+        };
+        /// The result is a single node.
+        template< typename node_t >
+        struct result1 {
+                bool differs = false;
+                const node_t * value = nullptr;
+                template< typename object_t, typename super_t, typename field_t >
+                void apply( object_t *, field_t super_t::* field );
+        };
+        /// The result is a container of statements.
+        template< template<class...> class container_t >
+        struct resultNstmt {
+                /// The delta/change on a single node.
+                struct delta {
+                        ptr<Stmt> new_val;
+                        ssize_t old_idx;
+                        bool is_old;
+                        delta(const Stmt * s, ssize_t i, bool old) :
+                                new_val(s), old_idx(i), is_old(old) {}
+                };
+                bool differs = false;
+                container_t< delta > values;
+                template< typename object_t, typename super_t, typename field_t >
+                void apply( object_t *, field_t super_t::* field );
+                template< template<class...> class incontainer_t >
+                void take_all( incontainer_t<ptr<Stmt>> * stmts );
+                template< template<class...> class incontainer_t >
+                void take_all( incontainer_t<ptr<Decl>> * decls );
+        };
+        /// The result is a container of nodes.
+        template< template<class...> class container_t, typename node_t >
+        struct resultN {
+                bool differs = false;
+                container_t<ptr<node_t>> values;
+                template< typename object_t, typename super_t, typename field_t >
+                void apply( object_t *, field_t super_t::* field );
+        };
+        /// Used by previsit implementation
+        /// We need to reassign the result to 'node', unless the function
+        /// returns void, then we just leave 'node' unchanged
+        template<bool is_void>
+        struct __assign;
+        template<>
+        struct __assign<true> {
+                template<typename core_t, typename node_t>
+                static inline void result( core_t & core, const node_t * & node ) {
+                        core.previsit( node );
+                }
+        };
+        template<>
+        struct __assign<false> {
+                template<typename core_t, typename node_t>
+                static inline void result( core_t & core, const node_t * & node ) {
+                        node = core.previsit( node );
+                        assertf(node, "Previsit must not return NULL");
+                }
+        };
+        /// Used by postvisit implementation
+        /// We need to return the result unless the function
+        /// returns void, then we just return the original node
+        template<bool is_void>
+        struct __return;
+        template<>
+        struct __return<true> {
+                template<typename core_t, typename node_t>
+                static inline const node_t * result( core_t & core, const node_t * & node ) {
+                        core.postvisit( node );
+                        return node;
+                }
+        };
+        template<>
+        struct __return<false> {
+                template<typename core_t, typename node_t>
+                static inline auto result( core_t & core, const node_t * & node ) {
+                        return core.postvisit( node );
+                }
+        };
+        //-------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+        // Deep magic (a.k.a template meta programming) to make the templated visitor work
+        // Basically the goal is to make 2 previsit
+        // 1 - Use when a pass implements a valid previsit. This uses overloading which means the any overload of
+        //     'pass.previsit( node )' that compiles will be used for that node for that type
+        //     This requires that this option only compile for passes that actually define an appropriate visit.
+        //     SFINAE will make sure the compilation errors in this function don't halt the build.
+        //     See http://en.cppreference.com/w/cpp/language/sfinae for details on SFINAE
+        // 2 - Since the first implementation might not be specilizable, the second implementation exists and does nothing.
+        //     This is needed only to eliminate the need for passes to specify any kind of handlers.
+        //     The second implementation only works because it has a lower priority. This is due to the bogus last parameter.
+        //     The second implementation takes a long while the first takes an int. Since the caller always passes an literal 0
+        //     the first implementation takes priority in regards to overloading.
+        //-------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+        // PreVisit : may mutate the pointer passed in if the node is mutated in the previsit call
+        static inline void result( core_t & core, const node_t * & node ) {
+                core.previsit( node );
+        }
+};
+template<>
+struct __assign<false> {
         template<typename core_t, typename node_t>
+        static inline auto previsit( core_t & core, const node_t * & node, int ) -> decltype( core.previsit( node ), void() ) {
+                static_assert(
+                        is_valid_previsit<core_t, node_t>::value,
+                        "Previsit may not change the type of the node. It must return its paremeter or void."
+                );
+                __assign<
+                        std::is_void<
+                                decltype( core.previsit( node ) )
+                        >::value
+                >::result( core, node );
+        }
+        static inline void result( core_t & core, const node_t * & node ) {
+                node = core.previsit( node );
+                assertf(node, "Previsit must not return NULL");
+        }
+};
+/// Used by postvisit implementation
+/// We need to return the result unless the function
+/// returns void, then we just return the original node
+template<bool is_void>
+struct __return;
+template<>
+struct __return<true> {
         template<typename core_t, typename node_t>
+        static inline auto previsit( core_t &, const node_t *, long ) {}
+        // PostVisit : never mutates the passed pointer but may return a different node
+        static inline const node_t * result( core_t & core, const node_t * & node ) {
+                core.postvisit( node );
+                return node;
+        }
+};
+template<>
+struct __return<false> {
         template<typename core_t, typename node_t>
+        static inline auto postvisit( core_t & core, const node_t * node, int ) ->
+                decltype( core.postvisit( node ), node->accept( *(Visitor*)nullptr ) )
+        {
+                return __return<
+                        std::is_void<
+                                decltype( core.postvisit( node ) )
+                        >::value
+                >::result( core, node );
+        }
+        template<typename core_t, typename node_t>
+        static inline const node_t * postvisit( core_t &, const node_t * node, long ) { return node; }
+        //-------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+        // Deep magic (a.k.a template meta programming) continued
+        // To make the templated visitor be more expressive, we allow 'accessories' : classes/structs the implementation can inherit
+        // from in order to get extra functionallity for example
+        // class ErrorChecker : WithShortCircuiting { ... };
+        // Pass<ErrorChecker> checker;
+        // this would define a pass that uses the templated visitor with the additionnal feature that it has short circuiting
+        // Note that in all cases the accessories are not required but guarantee the requirements of the feature is matched
+        //-------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+        // For several accessories, the feature is enabled by detecting that a specific field is present
+        // Use a macro the encapsulate the logic of detecting a particular field
+        // The type is not strictly enforced but does match the accessory
+        #define FIELD_PTR( name, default_type ) \
+        template< typename core_t > \
+        static inline auto name( core_t & core, int ) -> decltype( &core.name ) { return &core.name; } \
+        static inline auto result( core_t & core, const node_t * & node ) {
+                return core.postvisit( node );
+        }
+};
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+// Deep magic (a.k.a template meta programming) to make the templated visitor work
+// Basically the goal is to make 2 previsit
+// 1 - Use when a pass implements a valid previsit. This uses overloading which means the any overload of
+//     'pass.previsit( node )' that compiles will be used for that node for that type
+//     This requires that this option only compile for passes that actually define an appropriate visit.
+//     SFINAE will make sure the compilation errors in this function don't halt the build.
+//     See http://en.cppreference.com/w/cpp/language/sfinae for details on SFINAE
+// 2 - Since the first implementation might not be specilizable, the second implementation exists and does nothing.
+//     This is needed only to eliminate the need for passes to specify any kind of handlers.
+//     The second implementation only works because it has a lower priority. This is due to the bogus last parameter.
+//     The second implementation takes a long while the first takes an int. Since the caller always passes an literal 0
+//     the first implementation takes priority in regards to overloading.
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+// PreVisit : may mutate the pointer passed in if the node is mutated in the previsit call
+template<typename core_t, typename node_t>
+static inline auto previsit( core_t & core, const node_t * & node, int ) -> decltype( core.previsit( node ), void() ) {
+        static_assert(
+                is_valid_previsit<core_t, node_t>::value,
+                "Previsit may not change the type of the node. It must return its paremeter or void."
+        );
+        __assign<
+                std::is_void<
+                        decltype( core.previsit( node ) )
+                >::value
+        >::result( core, node );
+}
+template<typename core_t, typename node_t>
+static inline auto previsit( core_t &, const node_t *, long ) {}
+// PostVisit : never mutates the passed pointer but may return a different node
+template<typename core_t, typename node_t>
+static inline auto postvisit( core_t & core, const node_t * node, int ) ->
+        decltype( core.postvisit( node ), node->accept( *(Visitor*)nullptr ) )
+{
+        return __return<
+                std::is_void<
+                        decltype( core.postvisit( node ) )
+                >::value
+        >::result( core, node );
+}
+template<typename core_t, typename node_t>
+static inline const node_t * postvisit( core_t &, const node_t * node, long ) { return node; }
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+// Deep magic (a.k.a template meta programming) continued
+// To make the templated visitor be more expressive, we allow 'accessories' : classes/structs the implementation can inherit
+// from in order to get extra functionallity for example
+// class ErrorChecker : WithShortCircuiting { ... };
+// Pass<ErrorChecker> checker;
+// this would define a pass that uses the templated visitor with the additionnal feature that it has short circuiting
+// Note that in all cases the accessories are not required but guarantee the requirements of the feature is matched
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+// For several accessories, the feature is enabled by detecting that a specific field is present
+// Use a macro the encapsulate the logic of detecting a particular field
+// The type is not strictly enforced but does match the accessory
+#define FIELD_PTR( name, default_type ) \
+template< typename core_t > \
+static inline auto name( core_t & core, int ) -> decltype( &core.name ) { return &core.name; } \
+\
+template< typename core_t > \
+static inline default_type * name( core_t &, long ) { return nullptr; }
+// List of fields and their expected types
+FIELD_PTR( typeSubs, const ast::TypeSubstitution * )
+FIELD_PTR( stmtsToAddBefore, std::list< ast::ptr< ast::Stmt > > )
+FIELD_PTR( stmtsToAddAfter , std::list< ast::ptr< ast::Stmt > > )
+FIELD_PTR( declsToAddBefore, std::list< ast::ptr< ast::Decl > > )
+FIELD_PTR( declsToAddAfter , std::list< ast::ptr< ast::Decl > > )
+FIELD_PTR( visit_children, __pass::bool_ref )
+FIELD_PTR( at_cleanup, __pass::at_cleanup_t )
+FIELD_PTR( visitor, ast::Pass<core_t> * const )
+// Remove the macro to make sure we don't clash
+#undef FIELD_PTR
+template< typename core_t >
+static inline auto beginTrace(core_t &, int) -> decltype( core_t::traceId, void() ) {
+        // Stats::Heap::stacktrace_push(core_t::traceId);
+}
+template< typename core_t >
+static inline auto endTrace(core_t &, int) -> decltype( core_t::traceId, void() ) {
+        // Stats::Heap::stacktrace_pop();
+}
+template< typename core_t >
+static void beginTrace(core_t &, long) {}
+template< typename core_t >
+static void endTrace(core_t &, long) {}
+// Allows visitor to handle an error on top-level declarations, and possibly suppress the error.
+// If on_error() returns false, the error will be ignored. By default, it returns true.
+template< typename core_t >
+static bool on_error (core_t &, ptr<Decl> &, long) { return true; }
+template< typename core_t >
+static auto on_error (core_t & core, ptr<Decl> & decl, int) -> decltype(core.on_error(decl)) {
+        return core.on_error(decl);
+}
+template< typename core_t, typename node_t >
+static auto make_location_guard( core_t & core, node_t * node, int )
+                -> decltype( node->location, ValueGuardPtr<const CodeLocation *>( &core.location ) ) {
+        ValueGuardPtr<const CodeLocation *> guard( &core.location );
+        core.location = &node->location;
+        return guard;
+}
+template< typename core_t, typename node_t >
+static auto make_location_guard( core_t &, node_t *, long ) -> int {
+        return 0;
+}
+// Another feature of the templated visitor is that it calls beginScope()/endScope() for compound statement.
+// All passes which have such functions are assumed desire this behaviour
+// detect it using the same strategy
+namespace scope {
+        template<typename core_t>
+        static inline auto enter( core_t & core, int ) -> decltype( core.beginScope(), void() ) {
+                core.beginScope();
+        }
+        template<typename core_t>
+        static inline void enter( core_t &, long ) {}
+        template<typename core_t>
+        static inline auto leave( core_t & core, int ) -> decltype( core.endScope(), void() ) {
+                core.endScope();
+        }
+        template<typename core_t>
+        static inline void leave( core_t &, long ) {}
+} // namespace scope
+// Certain passes desire an up to date symbol table automatically
+// detect the presence of a member name `symtab` and call all the members appropriately
+namespace symtab {
+        // Some simple scoping rules
+        template<typename core_t>
+        static inline auto enter( core_t & core, int ) -> decltype( core.symtab, void() ) {
+                core.symtab.enterScope();
+        }
+        template<typename core_t>
+        static inline auto enter( core_t &, long ) {}
+        template<typename core_t>
+        static inline auto leave( core_t & core, int ) -> decltype( core.symtab, void() ) {
+                core.symtab.leaveScope();
+        }
+        template<typename core_t>
+        static inline auto leave( core_t &, long ) {}
+        // The symbol table has 2 kind of functions mostly, 1 argument and 2 arguments
+        // Create macro to condense these common patterns
+        #define SYMTAB_FUNC1( func, type ) \
+        template<typename core_t> \
+        static inline auto func( core_t & core, int, type arg ) -> decltype( core.symtab.func( arg ), void() ) {\
+                core.symtab.func( arg ); \
+        } \
+        \
+        template< typename core_t > \
+        static inline default_type * name( core_t &, long ) { return nullptr; }
+        // List of fields and their expected types
+        FIELD_PTR( typeSubs, const ast::TypeSubstitution * )
+        FIELD_PTR( stmtsToAddBefore, std::list< ast::ptr< ast::Stmt > > )
+        FIELD_PTR( stmtsToAddAfter , std::list< ast::ptr< ast::Stmt > > )
+        FIELD_PTR( declsToAddBefore, std::list< ast::ptr< ast::Decl > > )
+        FIELD_PTR( declsToAddAfter , std::list< ast::ptr< ast::Decl > > )
+        FIELD_PTR( visit_children, __pass::bool_ref )
+        FIELD_PTR( at_cleanup, __pass::at_cleanup_t )
+        FIELD_PTR( visitor, ast::Pass<core_t> * const )
+        // Remove the macro to make sure we don't clash
+        #undef FIELD_PTR
+        template< typename core_t >
+        static inline auto beginTrace(core_t &, int) -> decltype( core_t::traceId, void() ) {
+                // Stats::Heap::stacktrace_push(core_t::traceId);
+        }
+        template< typename core_t >
+        static inline auto endTrace(core_t &, int) -> decltype( core_t::traceId, void() ) {
+                // Stats::Heap::stacktrace_pop();
+        }
+        template< typename core_t >
+        static void beginTrace(core_t &, long) {}
+        template< typename core_t >
+        static void endTrace(core_t &, long) {}
+        // Allows visitor to handle an error on top-level declarations, and possibly suppress the error.
+        // If onError() returns false, the error will be ignored. By default, it returns true.
+        template< typename core_t >
+        static bool on_error (core_t &, ptr<Decl> &, long) { return true; }
+        template< typename core_t >
+        static auto on_error (core_t & core, ptr<Decl> & decl, int) -> decltype(core.on_error(decl)) {
+                return core.on_error(decl);
+        }
+        template< typename core_t, typename node_t >
+        static auto make_location_guard( core_t & core, node_t * node, int )
+                        -> decltype( node->location, ValueGuardPtr<const CodeLocation *>( &core.location ) ) {
+                ValueGuardPtr<const CodeLocation *> guard( &core.location );
+                core.location = &node->location;
+                return guard;
+        }
+        template< typename core_t, typename node_t >
+        static auto make_location_guard( core_t &, node_t *, long ) -> int {
+                return 0;
+        }
+        // Another feature of the templated visitor is that it calls beginScope()/endScope() for compound statement.
+        // All passes which have such functions are assumed desire this behaviour
+        // detect it using the same strategy
+        namespace scope {
+                template<typename core_t>
+                static inline auto enter( core_t & core, int ) -> decltype( core.beginScope(), void() ) {
+                        core.beginScope();
+                }
+                template<typename core_t>
+                static inline void enter( core_t &, long ) {}
+                template<typename core_t>
+                static inline auto leave( core_t & core, int ) -> decltype( core.endScope(), void() ) {
+                        core.endScope();
+                }
+                template<typename core_t>
+                static inline void leave( core_t &, long ) {}
+        } // namespace scope
+        // Certain passes desire an up to date symbol table automatically
+        // detect the presence of a member name `symtab` and call all the members appropriately
+        namespace symtab {
+                // Some simple scoping rules
+                template<typename core_t>
+                static inline auto enter( core_t & core, int ) -> decltype( core.symtab, void() ) {
+                        core.symtab.enterScope();
+                }
+                template<typename core_t>
+                static inline auto enter( core_t &, long ) {}
+                template<typename core_t>
+                static inline auto leave( core_t & core, int ) -> decltype( core.symtab, void() ) {
+                        core.symtab.leaveScope();
+                }
+                template<typename core_t>
+                static inline auto leave( core_t &, long ) {}
+                // The symbol table has 2 kind of functions mostly, 1 argument and 2 arguments
+                // Create macro to condense these common patterns
+                #define SYMTAB_FUNC1( func, type ) \
+                template<typename core_t> \
+                static inline auto func( core_t & core, int, type arg ) -> decltype( core.symtab.func( arg ), void() ) {\
+                        core.symtab.func( arg ); \
+                } \
+                \
+                template<typename core_t> \
+                static inline void func( core_t &, long, type ) {}
+                #define SYMTAB_FUNC2( func, type1, type2 ) \
+                template<typename core_t> \
+                static inline auto func( core_t & core, int, type1 arg1, type2 arg2 ) -> decltype( core.symtab.func( arg1, arg2 ), void () ) {\
+                        core.symtab.func( arg1, arg2 ); \
+                } \
+                        \
+                template<typename core_t> \
+                static inline void func( core_t &, long, type1, type2 ) {}
+                SYMTAB_FUNC1( addId     , const DeclWithType *  );
+                SYMTAB_FUNC1( addType   , const NamedTypeDecl * );
+                SYMTAB_FUNC1( addStruct , const StructDecl *    );
+                SYMTAB_FUNC1( addEnum   , const EnumDecl *      );
+                SYMTAB_FUNC1( addUnion  , const UnionDecl *     );
+                SYMTAB_FUNC1( addTrait  , const TraitDecl *     );
+                SYMTAB_FUNC2( addWith   , const std::vector< ptr<Expr> > &, const Decl * );
+                // A few extra functions have more complicated behaviour, they are hand written
+                template<typename core_t>
+                static inline auto addStructFwd( core_t & core, int, const ast::StructDecl * decl ) -> decltype( core.symtab.addStruct( decl ), void() ) {
+                        ast::StructDecl * fwd = new ast::StructDecl( decl->location, decl->name );
+                        for ( const auto & param : decl->params ) {
+                                fwd->params.push_back( deepCopy( param.get() ) );
+                        }
+                        core.symtab.addStruct( fwd );
+                }
+                template<typename core_t>
+                static inline void addStructFwd( core_t &, long, const ast::StructDecl * ) {}
+                template<typename core_t>
+                static inline auto addUnionFwd( core_t & core, int, const ast::UnionDecl * decl ) -> decltype( core.symtab.addUnion( decl ), void() ) {
+                        ast::UnionDecl * fwd = new ast::UnionDecl( decl->location, decl->name );
+                        for ( const auto & param : decl->params ) {
+                                fwd->params.push_back( deepCopy( param.get() ) );
+                        }
+                        core.symtab.addUnion( fwd );
+                }
+                template<typename core_t>
+                static inline void addUnionFwd( core_t &, long, const ast::UnionDecl * ) {}
+                template<typename core_t>
+                static inline auto addStruct( core_t & core, int, const std::string & str ) -> decltype( core.symtab.addStruct( str ), void() ) {
+                        if ( ! core.symtab.lookupStruct( str ) ) {
+                                core.symtab.addStruct( str );
+                        }
+                }
+                template<typename core_t>
+                static inline void addStruct( core_t &, long, const std::string & ) {}
+                template<typename core_t>
+                static inline auto addUnion( core_t & core, int, const std::string & str ) -> decltype( core.symtab.addUnion( str ), void() ) {
+                        if ( ! core.symtab.lookupUnion( str ) ) {
+                                core.symtab.addUnion( str );
+                        }
+                }
+                template<typename core_t>
+                static inline void addUnion( core_t &, long, const std::string & ) {}
+                #undef SYMTAB_FUNC1
+                #undef SYMTAB_FUNC2
+        } // namespace symtab
+        // Some passes need to mutate TypeDecl and properly update their pointing TypeInstType.
+        // Detect the presence of a member name `subs` and call all members appropriately
+        namespace forall {
+                // Some simple scoping rules
+                template<typename core_t>
+                static inline auto enter( core_t & core, int, const ast::FunctionType * type )
+                -> decltype( core.subs, void() ) {
+                        if ( ! type->forall.empty() ) core.subs.beginScope();
+                }
+                template<typename core_t>
+                static inline auto enter( core_t &, long, const ast::FunctionType * ) {}
+                template<typename core_t>
+                static inline auto leave( core_t & core, int, const ast::FunctionType * type )
+                -> decltype( core.subs, void() ) {
+                        if ( ! type->forall.empty() ) { core.subs.endScope(); }
+                }
+                template<typename core_t>
+                static inline auto leave( core_t &, long, const ast::FunctionType * ) {}
+                // Replaces a TypeInstType's base TypeDecl according to the table
+                template<typename core_t>
+                static inline auto replace( core_t & core, int, const ast::TypeInstType *& inst )
+                -> decltype( core.subs, void() ) {
+                        inst = ast::mutate_field(
+                                inst, &ast::TypeInstType::base, core.subs.replace( inst->base ) );
+                }
+                template<typename core_t>
+                static inline auto replace( core_t &, long, const ast::TypeInstType *& ) {}
+        } // namespace forall
+        // For passes that need access to the global context. Sreaches `translationUnit`
+        namespace translation_unit {
+                template<typename core_t>
+                static inline auto get_cptr( core_t & core, int )
+                                -> decltype( &core.translationUnit ) {
+                        return &core.translationUnit;
+                }
+                template<typename core_t>
+                static inline const TranslationUnit ** get_cptr( core_t &, long ) {
+                        return nullptr;
+                }
+        }
+        template<typename core_t>
+        static inline auto get_result( core_t & core, char ) -> decltype( core.result() ) {
+        template<typename core_t> \
+        static inline void func( core_t &, long, type ) {}
+        #define SYMTAB_FUNC2( func, type1, type2 ) \
+        template<typename core_t> \
+        static inline auto func( core_t & core, int, type1 arg1, type2 arg2 ) -> decltype( core.symtab.func( arg1, arg2 ), void () ) {\
+                core.symtab.func( arg1, arg2 ); \
+        } \
+        \
+        template<typename core_t> \
+        static inline void func( core_t &, long, type1, type2 ) {}
+        SYMTAB_FUNC1( addId     , const DeclWithType *  );
+        SYMTAB_FUNC1( addType   , const NamedTypeDecl * );
+        SYMTAB_FUNC1( addStruct , const StructDecl *    );
+        SYMTAB_FUNC1( addEnum   , const EnumDecl *      );
+        SYMTAB_FUNC1( addUnion  , const UnionDecl *     );
+        SYMTAB_FUNC1( addTrait  , const TraitDecl *     );
+        SYMTAB_FUNC2( addWith   , const std::vector< ptr<Expr> > &, const Decl * );
+        // A few extra functions have more complicated behaviour, they are hand written
+        template<typename core_t>
+        static inline auto addStructFwd( core_t & core, int, const ast::StructDecl * decl ) -> decltype( core.symtab.addStruct( decl ), void() ) {
+                ast::StructDecl * fwd = new ast::StructDecl( decl->location, decl->name );
+                for ( const auto & param : decl->params ) {
+                        fwd->params.push_back( deepCopy( param.get() ) );
+                }
+                core.symtab.addStruct( fwd );
+        }
+        template<typename core_t>
+        static inline void addStructFwd( core_t &, long, const ast::StructDecl * ) {}
+        template<typename core_t>
+        static inline auto addUnionFwd( core_t & core, int, const ast::UnionDecl * decl ) -> decltype( core.symtab.addUnion( decl ), void() ) {
+                ast::UnionDecl * fwd = new ast::UnionDecl( decl->location, decl->name );
+                for ( const auto & param : decl->params ) {
+                        fwd->params.push_back( deepCopy( param.get() ) );
+                }
+                core.symtab.addUnion( fwd );
+        }
+        template<typename core_t>
+        static inline void addUnionFwd( core_t &, long, const ast::UnionDecl * ) {}
+        template<typename core_t>
+        static inline auto addStruct( core_t & core, int, const std::string & str ) -> decltype( core.symtab.addStruct( str ), void() ) {
+                if ( ! core.symtab.lookupStruct( str ) ) {
+                        core.symtab.addStruct( str );
+                }
+        }
+        template<typename core_t>
+        static inline void addStruct( core_t &, long, const std::string & ) {}
+        template<typename core_t>
+        static inline auto addUnion( core_t & core, int, const std::string & str ) -> decltype( core.symtab.addUnion( str ), void() ) {
+                if ( ! core.symtab.lookupUnion( str ) ) {
+                        core.symtab.addUnion( str );
+                }
+        }
+        template<typename core_t>
+        static inline void addUnion( core_t &, long, const std::string & ) {}
+        #undef SYMTAB_FUNC1
+        #undef SYMTAB_FUNC2
+} // namespace symtab
+// Some passes need to mutate TypeDecl and properly update their pointing TypeInstType.
+// Detect the presence of a member name `subs` and call all members appropriately
+namespace forall {
+        // Some simple scoping rules
+        template<typename core_t>
+        static inline auto enter( core_t & core, int, const ast::FunctionType * type )
+                        -> decltype( core.subs, void() ) {
+                if ( ! type->forall.empty() ) core.subs.beginScope();
+        }
+        template<typename core_t>
+        static inline auto enter( core_t &, long, const ast::FunctionType * ) {}
+        template<typename core_t>
+        static inline auto leave( core_t & core, int, const ast::FunctionType * type )
+                        -> decltype( core.subs, void() ) {
+                if ( ! type->forall.empty() ) { core.subs.endScope(); }
+        }
+        template<typename core_t>
+        static inline auto leave( core_t &, long, const ast::FunctionType * ) {}
+        // Replaces a TypeInstType's base TypeDecl according to the table
+        template<typename core_t>
+        static inline auto replace( core_t & core, int, const ast::TypeInstType *& inst )
+                        -> decltype( core.subs, void() ) {
+                inst = ast::mutate_field(
+                        inst, &ast::TypeInstType::base, core.subs.replace( inst->base ) );
+        }
+        template<typename core_t>
+        static inline auto replace( core_t &, long, const ast::TypeInstType *& ) {}
+} // namespace forall
+// For passes that need access to the global context. Searches `translationUnit`
+namespace translation_unit {
+        template<typename core_t>
+        static inline auto get_cptr( core_t & core, int )
+                        -> decltype( &core.translationUnit ) {
+                return &core.translationUnit;
+        }
+        template<typename core_t>
+        static inline const TranslationUnit ** get_cptr( core_t &, long ) {
+                return nullptr;
+        }
+}
+// For passes, usually utility passes, that have a result.
+namespace result {
+        template<typename core_t>
+        static inline auto get( core_t & core, char ) -> decltype( core.result() ) {
                 return core.result();
+        }
         template<typename core_t>
         static inline auto get_result( core_t & core, int ) -> decltype( core.result ) {
+        static inline auto get( core_t & core, int ) -> decltype( core.result ) {
                 return core.result;
+        }
         template<typename core_t>
+        static inline void get_result( core_t &, long ) {}
+} // namespace __pass
+} // namespace ast
+        static inline void get( core_t &, long ) {}
+}
+} // namespace ast::__pass
+#undef __pedantic_pass_assertf
+#undef __pedantic_pass_assert

src/AST/Print.cpp

-              r34b4268
+              r24d6572
 #include "Print.hpp"
+#include "Attribute.hpp"
 #include "Decl.hpp"
 #include "Expr.hpp"
+#include "Init.hpp"
 #include "Stmt.hpp"
 #include "Type.hpp"
 #include "TypeSubstitution.hpp"
 #include "CompilationState.h"
+#include "Common/utility.h" // for group_iterate
+#include "Common/Iterate.hpp"
 using namespace std;
 …
 namespace ast {
+template <typename C, typename... T>
+constexpr array<C,sizeof...(T)> make_array(T&&... values)
+{
+        return array<C,sizeof...(T)>{
+                std::forward<T>(values)...
+        };
+namespace {
+template<typename C, typename... T>
+constexpr array<C, sizeof...(T)> make_array( T&&... values ) {
+        return array<C, sizeof...(T)>{ std::forward<T>( values )... };
+}
+namespace Names {
+        static constexpr auto FuncSpecifiers = make_array<const char*>(
+                "inline", "_Noreturn", "fortran"
+        );
+        static constexpr auto StorageClasses = make_array<const char*>(
+                "extern", "static", "auto", "register", "__thread", "_Thread_local"
+        );
+        static constexpr auto Qualifiers = make_array<const char*>(
+                "const", "restrict", "volatile", "mutex", "_Atomic"
+        );
+}
+template<typename bits_t, size_t N>
+void print( ostream & os, const bits_t & bits,
+                const array<const char *, N> & names ) {
+        if ( !bits.any() ) return;
+        for ( size_t i = 0 ; i < N ; i += 1 ) {
+                if ( bits[i] ) {
+                        os << names[i] << ' ';
+                }
+        }
+}
 …
         static const char* Names[];
-        struct Names {
-                static constexpr auto FuncSpecifiers = make_array<const char*>(
-                        "inline", "_Noreturn", "fortran"
-                );
-                static constexpr auto StorageClasses = make_array<const char*>(
-                        "extern", "static", "auto", "register", "__thread", "_Thread_local"
-                );
-                static constexpr auto Qualifiers = make_array<const char*>(
-                        "const", "restrict", "volatile", "mutex", "_Atomic"
-                );
-        };
-        template<typename storage_t, size_t N>
-        void print(const storage_t & storage, const array<const char *, N> & Names ) {
-                if ( storage.any() ) {
-                        for ( size_t i = 0; i < Names.size(); i += 1 ) {
-                                if ( storage[i] ) {
-                                        os << Names[i] << ' ';
+                                }
+                        }
+                }
+        }
-        void print( const ast::Function::Specs & specs ) {
-                print(specs, Names::FuncSpecifiers);
+        }
-        void print( const ast::Storage::Classes & storage ) {
-                print(storage, Names::StorageClasses);
+        }
-        void print( const ast::CV::Qualifiers & qualifiers ) {
-                print(qualifiers, Names::Qualifiers);
+        }
         void print( const std::vector<ast::Label> & labels ) {
                 if ( labels.empty() ) return;
 …
+        }
+    void print( const ast::WaitStmt * node ) {
+                if ( node->timeout_time ) {
+                        os << indent-1 << "timeout of:" << endl;
+                        node->timeout_time->accept( *this );
+                        if ( node->timeout_stmt ) {
+                                os << indent-1 << "... with statment:" << endl;
+                                node->timeout_stmt->accept( *this );
+                        }
+                        if ( node->timeout_cond ) {
+                                os << indent-1 << "... with condition:" << endl;
+                                node->timeout_cond->accept( *this );
+                        }
+                }
+                if ( node->else_stmt ) {
+                        os << indent-1 << "else:" << endl;
+                        node->else_stmt->accept( *this );
+                        if ( node->else_cond ) {
+                                os << indent-1 << "... with condition:" << endl;
+                                node->else_cond->accept( *this );
+                        }
+                }
+        }
         void preprint( const ast::NamedTypeDecl * node ) {
                 if ( ! node->name.empty() ) {
 …
+                }
                 print( node->storage );
+                ast::print( os, node->storage );
                 os << node->typeString();
 …
         void preprint( const ast::Type * node ) {
                 print( node->qualifiers );
+                ast::print( os, node->qualifiers );
+        }
 …
                 print( node->forall );
                 print( node->assertions );
                 print( node->qualifiers );
+                ast::print( os, node->qualifiers );
+        }
         void preprint( const ast::BaseInstType * node ) {
                 print( node->attributes );
                 print( node->qualifiers );
+                ast::print( os, node->qualifiers );
+        }
 …
+                }
                 print( node->storage );
+                ast::print( os, node->storage );
                 if ( node->type ) {
 …
                 if ( ! short_mode ) printAll( node->attributes );
+                print( node->storage );
+                print( node->funcSpec );
+                ast::print( os, node->storage );
+                ast::print( os, node->funcSpec );
                 if ( node->type && node->isTypeFixed ) {
 …
                                 --indent;
+                        }
+                }
+                if ( ! node->withExprs.empty() ) {
+                        // Not with a clause, but the 'with clause'.
+                        ++indent;
+                        os << " with clause" << endl << indent;
+                        printAll( node->withExprs );
+                        --indent;
+                }
 …
         virtual const ast::Stmt * visit( const ast::SuspendStmt * node ) override final {
                 os << "Suspend Statement";
                 switch (node->type) {
                         case ast::SuspendStmt::None     : os << " with implicit target"; break;
                         case ast::SuspendStmt::Generator: os << " for generator"; break;
                         case ast::SuspendStmt::Coroutine: os << " for coroutine"; break;
+                switch (node->kind) {
+                case ast::SuspendStmt::None     : os << " with implicit target"; break;
+                case ast::SuspendStmt::Generator: os << " for generator"; break;
+                case ast::SuspendStmt::Coroutine: os << " for coroutine"; break;
+                }
                 os << endl;
 …
+                }
                 ++indent;
+                return node;
+        }
+        virtual const ast::WhenClause * visit( const ast::WhenClause * node ) override final {
+                os << indent-1 << "target: ";
+                safe_print( node->target );
+                if ( node->stmt ) {
+                        os << indent-1 << "... with statment:" << endl;
+                        node->stmt->accept( *this );
+                }
+                if ( node->when_cond ) {
+                        os << indent-1 << "... with when condition:" << endl;
+                        node->when_cond->accept( *this );
+                }
                 return node;
 …
         virtual const ast::WaitForClause * visit( const ast::WaitForClause * node ) override final {
                 os << indent-1 << "target function: ";
                 safe_print( node->target_func );
+                safe_print( node->target );
                 if ( !node->target_args.empty() ) {
 …
+                }
                 if ( node->cond ) {
+                if ( node->when_cond ) {
                         os << indent-1 << "... with condition:" << endl;
+                        node->cond->accept( *this );
+                }
+                        node->when_cond->accept( *this );
+                }
+                return node;
+        }
+    virtual const ast::Stmt * visit( const ast::WaitUntilStmt * node ) override final {
+                os << "Waituntil Statement" << endl;
+                indent += 2;
+                for( const auto & clause : node->clauses ) {
+                        clause->accept( *this );
+                }
+        print(node);    // calls print( const ast::WaitStmt * node )
                 return node;
+        }
 …
 };
+} // namespace
 void print( ostream & os, const ast::Node * node, Indenter indent ) {
         Printer printer { os, indent, false };
 …
+}
+// Annoyingly these needed to be defined out of line to avoid undefined references.
+// The size here needs to be explicit but at least the compiler will produce an error
+// if the wrong size is specified
+constexpr array<const char*, 3> Printer::Names::FuncSpecifiers;
+constexpr array<const char*, 6> Printer::Names::StorageClasses;
+constexpr array<const char*, 5> Printer::Names::Qualifiers;
+void print( ostream & os, Function::Specs specs ) {
+        print( os, specs, Names::FuncSpecifiers );
+}
+void print( ostream & os, Storage::Classes storage ) {
+        print( os, storage, Names::StorageClasses );
+}
+void print( ostream & os, CV::Qualifiers qualifiers ) {
+        print( os, qualifiers, Names::Qualifiers );
+}
+} // namespace ast

src/AST/Print.hpp

-              r34b4268
+              r24d6572
 #pragma once
+#include <iostream>
+#include <utility>   // for forward
+#include <iosfwd>
 #include "AST/Node.hpp"
+#include "AST/Fwd.hpp"
 #include "Common/Indenter.h"
 namespace ast {
-class Decl;
 /// Print a node with the given indenter
 …
+}
+/// Print each cv-qualifier used in the set, followed by a space.
+void print( std::ostream & os, CV::Qualifiers );
+/// Print each function specifier used in the set, followed by a space.
+void print( std::ostream & os, Function::Specs );
+/// Print each storage class used in the set, followed by a space.
+void print( std::ostream & os, Storage::Classes );
+}

src/AST/Stmt.hpp

-              r34b4268
+              r24d6572
 // Created On       : Wed May  8 13:00:00 2019
 // Last Modified By : Andrew Beach
 // Last Modified On : Wed Apr 20 14:34:00 2022
 // Update Count     : 36
+// Last Modified On : Wed Apr  5 10:34:00 2023
+// Update Count     : 37
 //
 …
 };
+// A while loop or a do-while loop:
+enum WhileDoKind { While, DoWhile };
 // While loop: while (...) ... else ... or do ... while (...) else ...;
 class WhileDoStmt final : public Stmt {
 …
         ptr<Stmt> else_;
         std::vector<ptr<Stmt>> inits;
         bool isDoWhile;
+        WhileDoKind isDoWhile;
         WhileDoStmt( const CodeLocation & loc, const Expr * cond, const Stmt * body,
                                  const std::vector<ptr<Stmt>> && inits, bool isDoWhile = false, const std::vector<Label> && labels = {} )
+                                 const std::vector<ptr<Stmt>> && inits, WhileDoKind isDoWhile = While, const std::vector<Label> && labels = {} )
                 : Stmt(loc, std::move(labels)), cond(cond), body(body), else_(nullptr), inits(std::move(inits)), isDoWhile(isDoWhile) {}
         WhileDoStmt( const CodeLocation & loc, const Expr * cond, const Stmt * body, const Stmt * else_,
                                  const std::vector<ptr<Stmt>> && inits, bool isDoWhile = false, const std::vector<Label> && labels = {} )
+                                 const std::vector<ptr<Stmt>> && inits, WhileDoKind isDoWhile = While, const std::vector<Label> && labels = {} )
                 : Stmt(loc, std::move(labels)), cond(cond), body(body), else_(else_), inits(std::move(inits)), isDoWhile(isDoWhile) {}
 …
   public:
         ptr<CompoundStmt> then;
         enum Type { None, Coroutine, Generator } type = None;
         SuspendStmt( const CodeLocation & loc, const CompoundStmt * then, Type type, const std::vector<Label> && labels = {} )
                 : Stmt(loc, std::move(labels)), then(then), type(type) {}
+        enum Kind { None, Coroutine, Generator } kind = None;
+        SuspendStmt( const CodeLocation & loc, const CompoundStmt * then, Kind kind, const std::vector<Label> && labels = {} )
+                : Stmt(loc, std::move(labels)), then(then), kind(kind) {}
         const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
 …
 };
 // Waitfor statement: when (...) waitfor (... , ...) ... timeout(...) ... else ...
+class WaitForStmt final : public Stmt {
+  public:
+        std::vector<ptr<WaitForClause>> clauses;
         ptr<Expr> timeout_time;
+// Base class of WaitFor/WaitUntil statements
+// form: KEYWORD(...) ... timeout(...) ... else ...
+class WaitStmt : public Stmt {
+  public:
+    ptr<Expr> timeout_time;
         ptr<Stmt> timeout_stmt;
         ptr<Expr> timeout_cond;
 …
         ptr<Expr> else_cond;
+    WaitStmt( const CodeLocation & loc, const std::vector<Label> && labels = {} )
+                : Stmt(loc, std::move(labels)) {}
+  private:
+    WaitStmt * clone() const override = 0;
+        MUTATE_FRIEND
+};
+// Base class for WaitFor/WaitUntil clauses
+// form: when( when_cond ) KEYWORD( target ) stmt
+class WhenClause : public StmtClause {
+  public:
+        ptr<Expr> target;
+        ptr<Stmt> stmt;
+        ptr<Expr> when_cond;
+        WhenClause( const CodeLocation & loc )
+                : StmtClause( loc ) {}
+        const WhenClause * accept( Visitor & v ) const override { return v.visit( this ); }
+  private:
+        WhenClause * clone() const override { return new WhenClause{ *this }; }
+        MUTATE_FRIEND
+};
+// Waitfor statement: when (...) waitfor (... , ...) ... timeout(...) ... else ...
+class WaitForStmt final : public WaitStmt {
+  public:
+        std::vector<ptr<WaitForClause>> clauses;
         WaitForStmt( const CodeLocation & loc, const std::vector<Label> && labels = {} )
                 : Stmt(loc, std::move(labels)) {}
+                : WaitStmt(loc, std::move(labels)) {}
         const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
 …
 };
+class WaitForClause final : public StmtClause {
+  public:
+        ptr<Expr> target_func;
+// Clause in a waitfor statement: waitfor (..., ...) ...
+class WaitForClause final : public WhenClause {
+  public:
         std::vector<ptr<Expr>> target_args;
-        ptr<Stmt> stmt;
-        ptr<Expr> cond;
         WaitForClause( const CodeLocation & loc )
                 : StmtClause( loc ) {}
+                : WhenClause( loc ) {}
         const WaitForClause * accept( Visitor & v ) const override { return v.visit( this ); }
   private:
         WaitForClause * clone() const override { return new WaitForClause{ *this }; }
+        MUTATE_FRIEND
+};
+// waituntil statement: when (...) waituntil (...) ... timeout(...) ... else ...
+class WaitUntilStmt final : public WaitStmt {
+  public:
+    // Non-ast node used during compilation to store data needed to generate predicates
+    //    and set initial status values for clauses
+    // Used to create a tree corresponding to the structure of the clauses in a WaitUntil
+    struct ClauseNode {
+        enum Op { AND, OR, LEFT_OR, LEAF, ELSE, TIMEOUT } op; // operation/type tag
+        // LEFT_OR used with TIMEOUT/ELSE to indicate that we ignore right hand side after parsing
+        ClauseNode * left;
+        ClauseNode * right;
+        WhenClause * leaf;  // only set if this node is a leaf (points into vector of clauses)
+        bool ambiguousWhen; // used to paint nodes of predicate tree based on when() clauses
+        bool whenState;     // used to track if when_cond is toggled on or off for generating init values
+        bool childOfAnd;      // true on leaf nodes that are children of AND, false otherwise
+        ClauseNode( Op op, ClauseNode * left, ClauseNode * right )
+            : op(op), left(left), right(right), leaf(nullptr),
+            ambiguousWhen(false), whenState(true), childOfAnd(false) {}
+        ClauseNode( Op op, WhenClause * leaf )
+            : op(op), left(nullptr), right(nullptr), leaf(leaf),
+            ambiguousWhen(false), whenState(true), childOfAnd(false) {}
+        ClauseNode( WhenClause * leaf ) : ClauseNode(LEAF, leaf) {}
+        ~ClauseNode() {
+            if ( left ) delete left;
+            if ( right ) delete right;
+        }
+    };
+        std::vector<ptr<WhenClause>> clauses;
+    ClauseNode * predicateTree;
+        WaitUntilStmt( const CodeLocation & loc, const std::vector<Label> && labels = {} )
+                : WaitStmt(loc, std::move(labels)) {}
+    ~WaitUntilStmt() { delete predicateTree; }
+        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
+  private:
+        WaitUntilStmt * clone() const override { return new WaitUntilStmt{ *this }; }
         MUTATE_FRIEND
 };
 …
         MUTATE_FRIEND
 };
 } // namespace ast

src/AST/SymbolTable.cpp

-              r34b4268
+              r24d6572
 #include <cassert>
+#include "Copy.hpp"
+#include <iostream>
+#include <algorithm>
 #include "Decl.hpp"
 #include "Expr.hpp"
 #include "Inspect.hpp"
 #include "Type.hpp"
 #include "CodeGen/OperatorTable.h"  // for isCtorDtorAssign
+#include "CodeGen/OperatorTable.h"         // for isCtorDtorAssign
 #include "Common/SemanticError.h"
 #include "Common/Stats/Counter.h"
 …
 #include "InitTweak/InitTweak.h"
 #include "ResolvExpr/Cost.h"
+#include "ResolvExpr/typeops.h"
+#include "ResolvExpr/CandidateFinder.hpp"  // for referenceToRvalueConversion
+#include "ResolvExpr/Unify.h"
 #include "SymTab/Mangler.h"
 …
         if ( baseExpr ) {
                 if (baseExpr->env) {
                         Expr * base = shallowCopy(baseExpr);
+                        Expr * base = deepCopy(baseExpr);
                         const TypeSubstitution * subs = baseExpr->env;
                         base->env = nullptr;
 …
                         out.push_back(decl.second);
+                }
+                // std::cerr << otypeKey << ' ' << out.size() << std::endl;
+        }
 …
 void SymbolTable::addId( const DeclWithType * decl, const Expr * baseExpr ) {
         // default handling of conflicts is to raise an error
         addId( decl, OnConflict::error(), baseExpr, decl->isDeleted ? decl : nullptr );
+        addIdCommon( decl, OnConflict::error(), baseExpr, decl->isDeleted ? decl : nullptr );
+}
 void SymbolTable::addDeletedId( const DeclWithType * decl, const Decl * deleter ) {
         // default handling of conflicts is to raise an error
         addId( decl, OnConflict::error(), nullptr, deleter );
+        addIdCommon( decl, OnConflict::error(), nullptr, deleter );
+}
 …
                 } else {
                         // typedef redeclarations are errors only if types are different
                         if ( ! ResolvExpr::typesCompatible( existing->base, added->base, SymbolTable{} ) ) {
+                        if ( ! ResolvExpr::typesCompatible( existing->base, added->base ) ) {
                                 SemanticError( added->location, "redeclaration of " + added->name );
+                        }
 …
         } else if ( existing.id->linkage.is_mangled
                         || ResolvExpr::typesCompatible(
                                 added->get_type(), existing.id->get_type(), SymbolTable{} ) ) {
+                                added->get_type(), existing.id->get_type() ) ) {
                 // it is a conflict if one declaration is deleted and the other is not
 …
+}
 void SymbolTable::addId(
                 const DeclWithType * decl, SymbolTable::OnConflict handleConflicts, const Expr * baseExpr,
                 const Decl * deleter ) {
+void SymbolTable::addIdCommon(
+                const DeclWithType * decl, SymbolTable::OnConflict handleConflicts,
+                const Expr * baseExpr, const Decl * deleter ) {
         SpecialFunctionKind kind = getSpecialFunctionKind(decl->name);
         if (kind == NUMBER_OF_KINDS) { // not a special decl
                 addId(decl, decl->name, idTable, handleConflicts, baseExpr, deleter);
+                addIdToTable(decl, decl->name, idTable, handleConflicts, baseExpr, deleter);
+        }
         else {
 …
                         assertf(false, "special decl with non-function type");
+                }
+                addId(decl, key, specialFunctionTable[kind], handleConflicts, baseExpr, deleter);
+        }
+}
+void SymbolTable::addId(
+                const DeclWithType * decl, const std::string & lookupKey, IdTable::Ptr & table, SymbolTable::OnConflict handleConflicts, const Expr * baseExpr,
+                const Decl * deleter ) {
+                addIdToTable(decl, key, specialFunctionTable[kind], handleConflicts, baseExpr, deleter);
+        }
+}
+void SymbolTable::addIdToTable(
+                const DeclWithType * decl, const std::string & lookupKey,
+                IdTable::Ptr & table, SymbolTable::OnConflict handleConflicts,
+                const Expr * baseExpr, const Decl * deleter ) {
         ++*stats().add_calls;
         const std::string &name = decl->name;
 …
 void SymbolTable::addMembers(
                 const AggregateDecl * aggr, const Expr * expr, SymbolTable::OnConflict handleConflicts ) {
         for ( const Decl * decl : aggr->members ) {
                 if ( auto dwt = dynamic_cast< const DeclWithType * >( decl ) ) {
                         addId( dwt, handleConflicts, expr );
                         if ( dwt->name == "" ) {
                                 const Type * t = dwt->get_type()->stripReferences();
                                 if ( auto rty = dynamic_cast<const BaseInstType *>( t ) ) {
                                         if ( ! dynamic_cast<const StructInstType *>(rty)
                                                 && ! dynamic_cast<const UnionInstType *>(rty) ) continue;
                                         ResolvExpr::Cost cost = ResolvExpr::Cost::zero;
                                         ast::ptr<ast::TypeSubstitution> tmp = expr->env;
                                         expr = mutate_field(expr, &Expr::env, nullptr);
                                         const Expr * base = ResolvExpr::referenceToRvalueConversion( expr, cost );
                                         base = mutate_field(base, &Expr::env, tmp);
                                         addMembers(
+                                                rty->aggr(), new MemberExpr{ base->location, dwt, base }, handleConflicts );
+                                }
+                        }
+        for ( const ptr<Decl> & decl : aggr->members ) {
+                auto dwt = decl.as<DeclWithType>();
+                if ( nullptr == dwt ) continue;
+                addIdCommon( dwt, handleConflicts, expr );
+                // Inline through unnamed struct/union members.
+                if ( "" != dwt->name ) continue;
+                const Type * t = dwt->get_type()->stripReferences();
+                if ( auto rty = dynamic_cast<const BaseInstType *>( t ) ) {
+                        if ( ! dynamic_cast<const StructInstType *>(rty)
+                                && ! dynamic_cast<const UnionInstType *>(rty) ) continue;
+                        ResolvExpr::Cost cost = ResolvExpr::Cost::zero;
+                        ast::ptr<ast::TypeSubstitution> tmp = expr->env;
+                        expr = mutate_field(expr, &Expr::env, nullptr);
+                        const Expr * base = ResolvExpr::referenceToRvalueConversion( expr, cost );
+                        base = mutate_field(base, &Expr::env, tmp);
+                        addMembers(
+                                rty->aggr(), new MemberExpr{ base->location, dwt, base }, handleConflicts );
+                }
+        }

src/AST/SymbolTable.hpp

-              r34b4268
+              r24d6572
         /// common code for addId, addDeletedId, etc.
         void addId(
                 const DeclWithType * decl, OnConflict handleConflicts, const Expr * baseExpr = nullptr,
                 const Decl * deleter = nullptr );
+        void addIdCommon(
+                const DeclWithType * decl, OnConflict handleConflicts,
+                const Expr * baseExpr = nullptr, const Decl * deleter = nullptr );
         /// common code for addId when special decls are placed into separate tables
+        void addId(
+                const DeclWithType * decl, const std::string & lookupKey, IdTable::Ptr & idTable, OnConflict handleConflicts,
+        void addIdToTable(
+                const DeclWithType * decl, const std::string & lookupKey,
+                IdTable::Ptr & idTable, OnConflict handleConflicts,
                 const Expr * baseExpr = nullptr, const Decl * deleter = nullptr);
         /// adds all of the members of the Aggregate (addWith helper)
         void addMembers( const AggregateDecl * aggr, const Expr * expr, OnConflict handleConflicts );

src/AST/TranslationUnit.hpp

-              r34b4268
+              r24d6572
 // Created On       : Tue Jun 11 15:30:00 2019
 // Last Modified By : Andrew Beach
 // Last Modified On : Tue Mar 11 11:19:00 2022
 // Update Count     : 1
+// Last Modified On : Thr Mar  9 16:41:00 2023
+// Update Count     : 2
 //
 …
 #include <map>
 #include <vector>
+#include <list>
 #include "Fwd.hpp"
 …
         ptr<Type> sizeType;
         const FunctionDecl * dereference;
         const StructDecl * dtorStruct;
         const FunctionDecl * dtorDestroy;
+        const FunctionDecl * dereference = nullptr;
+        const StructDecl * dtorStruct = nullptr;
+        const FunctionDecl * dtorDestroy = nullptr;
 };

src/AST/Type.cpp

-              r34b4268
+              r24d6572
 // Created On       : Mon May 13 15:00:00 2019
 // Last Modified By : Andrew Beach
 // Last Modified On : Thu Nov 24  9:49:00 2022
 // Update Count     : 6
+// Last Modified On : Thu Apr  6 15:59:00 2023
+// Update Count     : 7
 //
 …
 TupleType::TupleType( std::vector<ptr<Type>> && ts, CV::Qualifiers q )
+: Type( q ), types( std::move(ts) ), members() {
+        // This constructor is awkward. `TupleType` needs to contain objects so that members can be
+        // named, but members without initializer nodes end up getting constructors, which breaks
+        // things. This happens because the object decls have to be visited so that their types are
+        // kept in sync with the types listed here. Ultimately, the types listed here should perhaps
+        // be eliminated and replaced with a list-view over members. The temporary solution is to
+        // make a `ListInit` with `maybeConstructed = false`, so when the object is visited it is not
+        // constructed. Potential better solutions include:
+        //   a) Separate `TupleType` from its declarations, into `TupleDecl` and `Tuple{Inst?}Type`,
+        //      similar to the aggregate types.
+        //   b) Separate initializer nodes better, e.g. add a `MaybeConstructed` node that is replaced
+        //      by `genInit`, rather than the current boolean flag.
+        members.reserve( types.size() );
+        for ( const Type * ty : types ) {
+                members.emplace_back( new ObjectDecl{
+                        CodeLocation(), "", ty, new ListInit( CodeLocation(), {}, {}, NoConstruct ),
+                        Storage::Classes{}, Linkage::Cforall } );
+        }
+}
+: Type( q ), types( std::move(ts) ) {}
 bool isUnboundType(const Type * type) {

src/AST/Type.hpp

-              r34b4268
+              r24d6572
 // Created On       : Thu May 9 10:00:00 2019
 // Last Modified By : Andrew Beach
 // Last Modified On : Thu Nov 24  9:47:00 2022
 // Update Count     : 8
+// Last Modified On : Thu Apr  6 15:58:00 2023
+// Update Count     : 9
 //
 …
 };
-/// Function variable arguments flag
-enum ArgumentFlag { FixedArgs, VariableArgs };
 /// Type of a function `[R1, R2](*)(P1, P2, P3)`
 class FunctionType final : public Type {
 …
 public:
         std::vector<ptr<Type>> types;
-        std::vector<ptr<Decl>> members;
         TupleType( std::vector<ptr<Type>> && ts, CV::Qualifiers q = {} );

src/AST/TypeEnvironment.cpp

-              r34b4268
+              r24d6572
 bool TypeEnvironment::combine(
                 const TypeEnvironment & o, OpenVarSet & open, const SymbolTable & symtab ) {
+                const TypeEnvironment & o, OpenVarSet & open ) {
         // short-circuit easy cases
         if ( o.empty() ) return true;
 …
                         EqvClass & r = *rt;
                         // merge bindings
                         if ( ! mergeBound( r, c, open, symtab ) ) return false;
+                        if ( ! mergeBound( r, c, open ) ) return false;
                         // merge previous unbound variables into this class, checking occurs if needed
                         if ( r.bound ) for ( const auto & u : c.vars ) {
 …
                                 } else if ( st != rt ) {
                                         // bound, but not to the same class
                                         if ( ! mergeClasses( rt, st, open, symtab ) ) return false;
+                                        if ( ! mergeClasses( rt, st, open ) ) return false;
                                 }       // ignore bound into the same class
+                        }
 …
 bool TypeEnvironment::bindVar(
                 const TypeInstType * typeInst, const Type * bindTo, const TypeData & data,
+                AssertionSet & need, AssertionSet & have, const OpenVarSet & open, WidenMode widen,
+                const SymbolTable & symtab
+                AssertionSet & need, AssertionSet & have, const OpenVarSet & open, WidenMode widen
 ) {
         // remove references from bound type, so that type variables can only bind to value types
 …
                         if ( unifyInexact(
                                         newType, target, *this, need, have, open,
                                         widen & WidenMode{ it->allowWidening, true }, symtab, common ) ) {
+                                        widen & WidenMode{ it->allowWidening, true }, common ) ) {
                                 if ( common ) {
                                         it->bound = std::move(common);
 …
                 const TypeInstType * var1, const TypeInstType * var2, TypeData && data,
                 AssertionSet & need, AssertionSet & have, const OpenVarSet & open,
                 WidenMode widen, const SymbolTable & symtab
+                WidenMode widen
 ) {
         auto c1 = internal_lookup( *var1 );
 …
                 if ( unifyInexact(
                                 newType1, newType2, *this, need, have, open, newWidenMode, symtab, common ) ) {
+                                newType1, newType2, *this, need, have, open, newWidenMode, common ) ) {
                         c1->vars.insert( c2->vars.begin(), c2->vars.end() );
                         c1->allowWidening = widen1 && widen2;
 …
 bool TypeEnvironment::mergeBound(
                 EqvClass & to, const EqvClass & from, OpenVarSet & open, const SymbolTable & symtab ) {
+                EqvClass & to, const EqvClass & from, OpenVarSet & open ) {
         if ( from.bound ) {
                 if ( to.bound ) {
 …
                         if ( unifyInexact(
                                         toType, fromType, *this, need, have, open, widen, symtab, common ) ) {
+                                        toType, fromType, *this, need, have, open, widen, common ) ) {
                                 // unifies, set common type if necessary
                                 if ( common ) {
 …
 bool TypeEnvironment::mergeClasses(
         ClassList::iterator to, ClassList::iterator from, OpenVarSet & open, const SymbolTable & symtab
+        ClassList::iterator to, ClassList::iterator from, OpenVarSet & open
 ) {
         EqvClass & r = *to, & s = *from;
         // ensure bounds match
         if ( ! mergeBound( r, s, open, symtab ) ) return false;
+        if ( ! mergeBound( r, s, open ) ) return false;
         // check safely bindable

src/AST/TypeEnvironment.hpp

-              r34b4268
+              r24d6572
                 int cmp = d1->var->name.compare( d2->var->name );
                 return cmp < 0 || ( cmp == 0 && d1->result < d2->result );
+                return cmp > 0 || ( cmp == 0 && d1->result < d2->result );
+        }
 };
 …
         /// Merge environment with this one, checking compatibility.
         /// Returns false if fails, but does NOT roll back partial changes.
         bool combine( const TypeEnvironment & o, OpenVarSet & openVars, const SymbolTable & symtab );
+        bool combine( const TypeEnvironment & o, OpenVarSet & openVars );
         /// Add all type variables in environment to open var list
 …
                 const TypeInstType * typeInst, const Type * bindTo, const TypeData & data,
                 AssertionSet & need, AssertionSet & have, const OpenVarSet & openVars,
                 ResolvExpr::WidenMode widen, const SymbolTable & symtab );
+                ResolvExpr::WidenMode widen );
         /// Binds the type classes represented by `var1` and `var2` together; will add one or both
 …
                 const TypeInstType * var1, const TypeInstType * var2, TypeData && data,
                 AssertionSet & need, AssertionSet & have, const OpenVarSet & openVars,
                 ResolvExpr::WidenMode widen, const SymbolTable & symtab );
+                ResolvExpr::WidenMode widen );
         /// Disallows widening for all bindings in the environment
 …
         /// Unifies the type bound of `to` with the type bound of `from`, returning false if fails
         bool mergeBound(
                 EqvClass & to, const EqvClass & from, OpenVarSet & openVars, const SymbolTable & symtab );
+                EqvClass & to, const EqvClass & from, OpenVarSet & openVars );
         /// Merges two type classes from local environment, returning false if fails
         bool mergeClasses(
+                ClassList::iterator to, ClassList::iterator from, OpenVarSet & openVars,
+                const SymbolTable & symtab );
+                ClassList::iterator to, ClassList::iterator from, OpenVarSet & openVars);
         /// Private lookup API; returns array index of string, or env.size() for not found

src/AST/TypeSubstitution.cpp

-              r34b4268
+              r24d6572
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Andrew Beach
+// Last Modified On : Mon Jun  3 13:26:00 2017
+// Update Count     : 5
+//
+// Last Modified On : Thr May 25 11:24:00 2023
+// Update Count     : 6
+//
+#include "TypeSubstitution.hpp"
 #include "Type.hpp"   // for TypeInstType, Type, StructInstType, UnionInstType
 #include "TypeSubstitution.hpp"
+#include "Pass.hpp"   // for Pass, PureVisitor, WithGuards, WithVisitorRef
 namespace ast {
-// size_t TypeSubstitution::Substituter::traceId = Stats::Heap::new_stacktrace_id("TypeSubstitution");
 TypeSubstitution::TypeSubstitution() {
 …
+}
+// definitition must happen after PassVisitor is included so that WithGuards can be used
+struct TypeSubstitution::Substituter : public WithGuards, public WithVisitorRef<Substituter>, public PureVisitor {
+        //static size_t traceId;
+        Substituter( const TypeSubstitution & sub, bool freeOnly ) : sub( sub ), freeOnly( freeOnly ) {}
+        const Type * postvisit( const TypeInstType * aggregateUseType );
+        /// Records type variable bindings from forall-statements
+        void previsit( const FunctionType * type );
+        /// Records type variable bindings from forall-statements and instantiations of generic types
+        // void handleAggregateType( const BaseInstType * type );
+        // void previsit( const StructInstType * aggregateUseType );
+        // void previsit( const UnionInstType * aggregateUseType );
+        const TypeSubstitution & sub;
+        int subCount = 0;
+        bool freeOnly;
+        typedef std::unordered_set< TypeEnvKey > BoundVarsType;
+        BoundVarsType boundVars;
+};
+// size_t TypeSubstitution::Substituter::traceId = Stats::Heap::new_stacktrace_id("TypeSubstitution");
 void TypeSubstitution::normalize() {
         Pass<Substituter> sub( *this, true );
 …
+                }
         } while ( sub.core.subCount );
+}
+TypeSubstitution::ApplyResult<Node> TypeSubstitution::applyBase(
+                const Node * input, bool isFree ) const {
+        assert( input );
+        Pass<Substituter> sub( *this, isFree );
+        const Node * output = input->accept( sub );
+        return { output, sub.core.subCount };
+}

src/AST/TypeSubstitution.hpp

-              r34b4268
+              r24d6572
 // Author           : Richard C. Bilson
 // 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 By : Andrew Beach
+// Last Modified On : Thr May 25 12:31:00 2023
+// Update Count     : 10
 //
 …
         TypeSubstitution &operator=( const TypeSubstitution &other );
         template< typename SynTreeClass >
+        template< typename node_t >
         struct ApplyResult {
                 ast::ptr<SynTreeClass> node;
+                ast::ptr<node_t> node;
                 int count;
         };
+        template< typename SynTreeClass > ApplyResult<SynTreeClass> apply( const SynTreeClass * input ) const;
+        template< typename SynTreeClass > ApplyResult<SynTreeClass> applyFree( const SynTreeClass * input ) const;
+        template< typename node_t >
+        ApplyResult<node_t> apply( const node_t * input ) const {
+                ApplyResult<Node> ret = applyBase( input, false );
+                return { ret.node.strict_as<node_t>(), ret.count };
+        }
         template< typename node_t, enum Node::ref_type ref_t >
         int apply( ptr_base< node_t, ref_t > & input ) const {
+                const node_t * p = input.get();
+                auto ret = apply(p);
+                input = ret.node;
+                ApplyResult<Node> ret = applyBase( input.get(), false );
+                input = ret.node.strict_as<node_t>();
                 return ret.count;
+        }
+        template< typename node_t >
+        ApplyResult<node_t> applyFree( const node_t * input ) const {
+                ApplyResult<Node> ret = applyBase( input, true );
+                return { ret.node.strict_as<node_t>(), ret.count };
+        }
         template< typename node_t, enum Node::ref_type ref_t >
         int applyFree( ptr_base< node_t, ref_t > & input ) const {
+                const node_t * p = input.get();
+                auto ret = applyFree(p);
+                input = ret.node;
+                ApplyResult<Node> ret = applyBase( input.get(), true );
+                input = ret.node.strict_as<node_t>();
                 return ret.count;
+        }
 …
         // Mutator that performs the substitution
         struct Substituter;
+        ApplyResult<Node> applyBase( const Node * input, bool isFree ) const;
         // TODO: worry about traversing into a forall-qualified function type or type decl with assertions
 …
 } // namespace ast
-// include needs to happen after TypeSubstitution is defined so that both TypeSubstitution and
-// PassVisitor are defined before PassVisitor implementation accesses TypeSubstitution internals.
-#include "Pass.hpp"
-#include "Copy.hpp"
-namespace ast {
-// definitition must happen after PassVisitor is included so that WithGuards can be used
-struct TypeSubstitution::Substituter : public WithGuards, public WithVisitorRef<Substituter>, public PureVisitor {
-                static size_t traceId;
-                Substituter( const TypeSubstitution & sub, bool freeOnly ) : sub( sub ), freeOnly( freeOnly ) {}
-                const Type * postvisit( const TypeInstType * aggregateUseType );
-                /// Records type variable bindings from forall-statements
-                void previsit( const FunctionType * type );
-                /// Records type variable bindings from forall-statements and instantiations of generic types
-                // void handleAggregateType( const BaseInstType * type );
-                // void previsit( const StructInstType * aggregateUseType );
-                // void previsit( const UnionInstType * aggregateUseType );
-                const TypeSubstitution & sub;
-                int subCount = 0;
-                bool freeOnly;
-                typedef std::unordered_set< TypeEnvKey > BoundVarsType;
-                BoundVarsType boundVars;
-};
-template< typename SynTreeClass >
-TypeSubstitution::ApplyResult<SynTreeClass> TypeSubstitution::apply( const SynTreeClass * input ) const {
-        assert( input );
-        Pass<Substituter> sub( *this, false );
-        input = strict_dynamic_cast< const SynTreeClass * >( input->accept( sub ) );
-        return { input, sub.core.subCount };
+}
-template< typename SynTreeClass >
-TypeSubstitution::ApplyResult<SynTreeClass> TypeSubstitution::applyFree( const SynTreeClass * input ) const {
-        assert( input );
-        Pass<Substituter> sub( *this, true );
-        input = strict_dynamic_cast< const SynTreeClass * >( input->accept( sub ) );
-        return { input, sub.core.subCount };
+}
-} // namespace ast
 // Local Variables: //
 // tab-width: 4 //

src/AST/Visitor.hpp

-              r34b4268
+              r24d6572
     virtual const ast::FinallyClause *    visit( const ast::FinallyClause        * ) = 0;
     virtual const ast::Stmt *             visit( const ast::SuspendStmt          * ) = 0;
+    virtual const ast::WhenClause *       visit( const ast::WhenClause           * ) = 0;
     virtual const ast::Stmt *             visit( const ast::WaitForStmt          * ) = 0;
     virtual const ast::WaitForClause *    visit( const ast::WaitForClause        * ) = 0;
+    virtual const ast::Stmt *             visit( const ast::WaitUntilStmt        * ) = 0;
     virtual const ast::Decl *             visit( const ast::WithStmt             * ) = 0;
     virtual const ast::NullStmt *         visit( const ast::NullStmt             * ) = 0;

src/AST/porting.md

-              r34b4268
+              r24d6572
 * `get_statement()` exclusively used for code location, replaced with `CodeLocation` field
 `CaseStmt`
+`CaseStmt` => `CaseClause`
 * `_isDefault` has been removed
   * `isDefault` calculates value from `cond`
 …
 * `block` -> `body` and `finallyBlock` -> `finally`
 `ThrowStmt` `CatchStmt`
+`ThrowStmt` and `CatchStmt` => `CatchClause`
 * moved `Kind` enums to shared `ast::ExceptionKind` enum
 `FinallyStmt`
+`FinallyStmt` => `FinallyClause`
 * `block` -> `body`
 …
 * Template class, with specializations and using to implement some other types:
   * `StructInstType`, `UnionInstType` & `EnumInstType`
+  * `baseStruct`, `baseUnion` & `baseEnum` => `base`
 `TypeInstType`

src/CodeGen/CodeGenerator.cc

-              r34b4268
+              r24d6572
 #include <cassert>                   // for assert, assertf
 #include <list>                      // for _List_iterator, list, list<>::it...
+#include <sstream>                   // for stringstream
 #include "AST/Decl.hpp"              // for DeclWithType
 #include "Common/UniqueName.h"       // for UniqueName
-#include "Common/utility.h"          // for CodeLocation, toString
 #include "GenType.h"                 // for genType
 #include "InitTweak/InitTweak.h"     // for getPointerBase
 …
+        }
+        template<typename pass_type>
+        inline void genEnumInitializer( PassVisitor<pass_type> * visitor, Type * baseType, std::ostream & output,
+        Initializer * init, long long * cur_val, Options options) {
+                auto baseTypeAsBasic = baseType ? dynamic_cast<BasicType *>( baseType ) : nullptr;
+                if ( init ) { // If value has an explicit initiazatior
+                        output << " = ";
+                        output << "(" << genType(baseType, "", options) << ")";
+                        init->accept( *visitor );
+                        if ( baseTypeAsBasic && baseTypeAsBasic->isInteger() ) { // if it is an integral type and initilizer offered,
+                        // need to update the cur_val
+                                Expression* expr = ((SingleInit *)(init))->value;
+                                while ( auto temp = dynamic_cast<CastExpr *>(expr) ) { // unwrap introduced cast
+                                        expr = temp->arg;
+                                }
+                                *cur_val = ((ConstantExpr *)expr)->constant.get_ival()+1;
+                        }
+                } else if ( baseTypeAsBasic && baseTypeAsBasic->isInteger() ) { // integral implicitly init to cur_val + 1
+                        output << " = " << "(" << genType(baseType, "", options) << ")";
+                        output << (*cur_val)++;
+                }
+        }
         void CodeGenerator::postvisit( EnumDecl * enumDecl ) {
                 extension( enumDecl );
                 std::list< Declaration* > &memb = enumDecl->get_members();
                 if (enumDecl->base && ! memb.empty()) {
+                        unsigned long long last_val = -1; // if the first enum value has no explicit initializer,
+                        // as other
+                        long long cur_val = 0;
                         for ( std::list< Declaration* >::iterator i = memb.begin(); i != memb.end();  i++) {
                                 ObjectDecl * obj = dynamic_cast< ObjectDecl* >( *i );
                                 assert( obj );
                                 output << "static ";
+                                output << genType(enumDecl->base, "", options) << " const ";
+                                output << mangleName( obj ) << " ";
+                                output << " = ";
+                                output << "(" << genType(enumDecl->base, "", options) << ")";
+                                if ( (BasicType *)(enumDecl->base) && ((BasicType *)(enumDecl->base))->isWholeNumber() ) {
+                                        if ( obj->get_init() ) {
+                                                obj->get_init()->accept( *visitor );
+                                                Expression* expr = ((SingleInit *)(obj->init))->value;
+                                                while ( auto temp = dynamic_cast<CastExpr *>(expr) ) {
+                                                        expr = temp->arg;
+                                                }
+                                                last_val = ((ConstantExpr *)expr)->constant.get_ival();
+                                        } else {
+                                                output << ++last_val;
+                                        } // if
+                                } else {
+                                        if ( obj->get_init() ) {
+                                                obj->get_init()->accept( *visitor );
+                                        } else {
+                                                // Should not reach here!
+                                        }
+                                }
+                                output << genType(enumDecl->base, mangleName( obj ), options);
+                                genEnumInitializer( visitor, enumDecl->base, output, obj->get_init(), &cur_val, options);
                                 output << ";" << endl;
                         } // for

src/CodeGen/GenType.cc

r34b4268	r24d6572
255	255	void GenType::postvisit( EnumInstType * enumInst ) {
256	256	if ( enumInst->baseEnum && enumInst->baseEnum->base ) {
257		typeString = genType(enumInst->baseEnum->base, ~~"", options) + typeString~~;
	257	typeString = genType(enumInst->baseEnum->base, typeString, options);
258	258	} else {
259	259	typeString = enumInst->name + " " + typeString;

src/Common/CodeLocationTools.cpp

-              r34b4268
+              r24d6572
     macro(FinallyClause, FinallyClause) \
     macro(SuspendStmt, Stmt) \
+    macro(WhenClause, WhenClause) \
     macro(WaitForStmt, Stmt) \
     macro(WaitForClause, WaitForClause) \
+    macro(WaitUntilStmt, Stmt) \
     macro(WithStmt, Decl) \
     macro(NullStmt, NullStmt) \
 …
 struct LeafKindVisitor : public ast::Visitor {
         LeafKind kind;
+        LeafKind result;
 #define VISIT(node_type, return_type) \
         const ast::return_type * visit( const ast::node_type * ) final { \
                 kind = LeafKind::node_type; \
+                result = LeafKind::node_type; \
                 return nullptr; \
+        }
 …
 LeafKind get_leaf_kind( ast::Node const * node ) {
+        LeafKindVisitor visitor;
+        node->accept( visitor );
+        return visitor.kind;
+        return ast::Pass<LeafKindVisitor>::read( node );
+}

src/Common/DeclStats.cpp

r34b4268	r24d6572
23	23	#include <iostream>
24	24	#include <map>
	25	#include <sstream>
25	26	#include <unordered_map>
26	27	#include <unordered_set>

src/Common/Eval.cc

-              r34b4268
+              r24d6572
 // file "LICENCE" distributed with Cforall.
 //
 // utility.h --
+// Eval.cc -- Evaluate parts of the ast at compile time.
 //
 // Author           : Richard C. Bilson
 …
 // Update Count     : 119
 //
+#include "Eval.h"
 #include <utility> // for pair

src/Common/ResolvProtoDump.cpp

-              r34b4268
+              r24d6572
 #include <iostream>
 #include <set>
+#include <sstream>
 #include <unordered_set>
 …
 #include "AST/Type.hpp"
 #include "CodeGen/OperatorTable.h"
-#include "Common/utility.h"
 namespace {

src/Common/ScopedMap.h

-              r34b4268
+              r24d6572
                 template<typename N>
                 Scope(N && n) : map(), note(std::forward<N>(n)) {}
                 Scope() = default;
                 Scope(const Scope &) = default;
 …
         typedef std::vector< Scope > ScopeList;
+        ScopeList scopes; ///< scoped list of maps
+        /// Scoped list of maps.
+        ScopeList scopes;
 public:
         typedef typename MapType::key_type key_type;
 …
         typedef typename MapType::const_pointer const_pointer;
+        class iterator : public std::iterator< std::bidirectional_iterator_tag, value_type > {
+        friend class ScopedMap;
+        friend class const_iterator;
+                typedef typename ScopedMap::MapType::iterator wrapped_iterator;
+                typedef typename ScopedMap::ScopeList scope_list;
+                typedef typename scope_list::size_type size_type;
+                /// Checks if this iterator points to a valid item
+                bool is_valid() const {
+                        return it != (*scopes)[level].map.end();
+                }
+                /// Increments on invalid
+                iterator & next_valid() {
+                        if ( ! is_valid() ) { ++(*this); }
+                        return *this;
+                }
+                /// Decrements on invalid
+                iterator & prev_valid() {
+                        if ( ! is_valid() ) { --(*this); }
+                        return *this;
+                }
+                iterator(scope_list & _scopes, const wrapped_iterator & _it, size_type inLevel)
+                        : scopes(&_scopes), it(_it), level(inLevel) {}
+        public:
+                iterator(const iterator & that) : scopes(that.scopes), it(that.it), level(that.level) {}
+                iterator & operator= (const iterator & that) {
+                        scopes = that.scopes; level = that.level; it = that.it;
+                        return *this;
+                }
+                reference operator* () { return *it; }
+                pointer operator-> () const { return it.operator->(); }
+                iterator & operator++ () {
+                        if ( it == (*scopes)[level].map.end() ) {
+                                if ( level == 0 ) return *this;
+                                --level;
+                                it = (*scopes)[level].map.begin();
+                        } else {
+                                ++it;
+                        }
+                        return next_valid();
+                }
+                iterator operator++ (int) { iterator tmp = *this; ++(*this); return tmp; }
+                iterator & operator-- () {
+                        // may fail if this is the begin iterator; allowed by STL spec
+                        if ( it == (*scopes)[level].map.begin() ) {
+                                ++level;
+                                it = (*scopes)[level].map.end();
+                        }
+                        --it;
+                        return prev_valid();
+                }
+                iterator operator-- (int) { iterator tmp = *this; --(*this); return tmp; }
+                bool operator== (const iterator & that) const {
+                        return scopes == that.scopes && level == that.level && it == that.it;
+                }
+                bool operator!= (const iterator & that) const { return !( *this == that ); }
+                size_type get_level() const { return level; }
+                Note & get_note() { return (*scopes)[level].note; }
+                const Note & get_note() const { return (*scopes)[level].note; }
+        private:
+                scope_list *scopes;
+                wrapped_iterator it;
+                size_type level;
+        };
+        class const_iterator : public std::iterator< std::bidirectional_iterator_tag,
+                                                     value_type > {
+        friend class ScopedMap;
+                typedef typename ScopedMap::MapType::iterator wrapped_iterator;
+                typedef typename ScopedMap::MapType::const_iterator wrapped_const_iterator;
+                typedef typename ScopedMap::ScopeList scope_list;
+                typedef typename scope_list::size_type size_type;
+                /// Checks if this iterator points to a valid item
+                bool is_valid() const {
+                        return it != (*scopes)[level].map.end();
+                }
+                /// Increments on invalid
+                const_iterator & next_valid() {
+                        if ( ! is_valid() ) { ++(*this); }
+                        return *this;
+                }
+                /// Decrements on invalid
+                const_iterator & prev_valid() {
+                        if ( ! is_valid() ) { --(*this); }
+                        return *this;
+                }
+                const_iterator(scope_list const & _scopes, const wrapped_const_iterator & _it, size_type inLevel)
+                        : scopes(&_scopes), it(_it), level(inLevel) {}
+        public:
+                const_iterator(const iterator & that) : scopes(that.scopes), it(that.it), level(that.level) {}
+                const_iterator(const const_iterator & that) : scopes(that.scopes), it(that.it), level(that.level) {}
+                const_iterator & operator= (const iterator & that) {
+                        scopes = that.scopes; level = that.level; it = that.it;
+                        return *this;
+                }
+                const_iterator & operator= (const const_iterator & that) {
+                        scopes = that.scopes; level = that.level; it = that.it;
+                        return *this;
+                }
+                const_reference operator* () { return *it; }
+                const_pointer operator-> () { return it.operator->(); }
+                const_iterator & operator++ () {
+                        if ( it == (*scopes)[level].map.end() ) {
+                                if ( level == 0 ) return *this;
+                                --level;
+                                it = (*scopes)[level].map.begin();
+                        } else {
+                                ++it;
+                        }
+                        return next_valid();
+                }
+                const_iterator operator++ (int) { const_iterator tmp = *this; ++(*this); return tmp; }
+                const_iterator & operator-- () {
+                        // may fail if this is the begin iterator; allowed by STL spec
+                        if ( it == (*scopes)[level].map.begin() ) {
+                                ++level;
+                                it = (*scopes)[level].map.end();
+                        }
+                        --it;
+                        return prev_valid();
+                }
+                const_iterator operator-- (int) { const_iterator tmp = *this; --(*this); return tmp; }
+                bool operator== (const const_iterator & that) const {
+                        return scopes == that.scopes && level == that.level && it == that.it;
+                }
+                bool operator!= (const const_iterator & that) const { return !( *this == that ); }
+                size_type get_level() const { return level; }
+                const Note & get_note() const { return (*scopes)[level].note; }
+        private:
+                scope_list const *scopes;
+                wrapped_const_iterator it;
+                size_type level;
+        };
+        // Both iterator types are complete bidrectional iterators, see below.
+        class iterator;
+        class const_iterator;
         /// Starts a new scope
 …
+        }
-        template< typename value_type_t >
-        std::pair< iterator, bool > insert( iterator at, value_type_t && value ) {
-                MapType & scope = (*at.scopes)[ at.level ].map;
-                std::pair< typename MapType::iterator, bool > res = scope.insert( std::forward<value_type_t>( value ) );
-                return std::make_pair( iterator(scopes, std::move( res.first ), at.level), std::move( res.second ) );
+        }
         template< typename value_t >
         std::pair< iterator, bool > insert( const Key & key, value_t && value ) { return insert( std::make_pair( key, std::forward<value_t>( value ) ) ); }
 …
+        }
+        iterator erase( iterator pos ) {
+                MapType & scope = (*pos.scopes)[ pos.level ].map;
+                const typename iterator::wrapped_iterator & new_it = scope.erase( pos.it );
+                iterator it( *pos.scopes, new_it, pos.level );
+                return it.next_valid();
+        /// Erases element with key in the innermost scope that has it.
+        size_type erase( const Key & key ) {
+                for ( auto it = scopes.rbegin() ; it != scopes.rend() ; ++it ) {
+                        size_type i = it->map.erase( key );
+                        if ( 0 != i ) return i;
+                }
+                return 0;
+        }
 …
                 return c;
+        }
+        bool contains( const Key & key ) const {
+                return find( key ) != cend();
+        }
+};
+template<typename Key, typename Value, typename Note>
+class ScopedMap<Key, Value, Note>::iterator :
+                public std::iterator< std::bidirectional_iterator_tag, value_type > {
+        friend class ScopedMap;
+        friend class const_iterator;
+        typedef typename ScopedMap::MapType::iterator wrapped_iterator;
+        typedef typename ScopedMap::ScopeList scope_list;
+        typedef typename scope_list::size_type size_type;
+        /// Checks if this iterator points to a valid item
+        bool is_valid() const {
+                return it != (*scopes)[level].map.end();
+        }
+        /// Increments on invalid
+        iterator & next_valid() {
+                if ( ! is_valid() ) { ++(*this); }
+                return *this;
+        }
+        /// Decrements on invalid
+        iterator & prev_valid() {
+                if ( ! is_valid() ) { --(*this); }
+                return *this;
+        }
+        iterator(scope_list & _scopes, const wrapped_iterator & _it, size_type inLevel)
+                : scopes(&_scopes), it(_it), level(inLevel) {}
+public:
+        iterator(const iterator & that) : scopes(that.scopes), it(that.it), level(that.level) {}
+        iterator & operator= (const iterator & that) {
+                scopes = that.scopes; level = that.level; it = that.it;
+                return *this;
+        }
+        reference operator* () { return *it; }
+        pointer operator-> () const { return it.operator->(); }
+        iterator & operator++ () {
+                if ( it == (*scopes)[level].map.end() ) {
+                        if ( level == 0 ) return *this;
+                        --level;
+                        it = (*scopes)[level].map.begin();
+                } else {
+                        ++it;
+                }
+                return next_valid();
+        }
+        iterator operator++ (int) { iterator tmp = *this; ++(*this); return tmp; }
+        iterator & operator-- () {
+                // may fail if this is the begin iterator; allowed by STL spec
+                if ( it == (*scopes)[level].map.begin() ) {
+                        ++level;
+                        it = (*scopes)[level].map.end();
+                }
+                --it;
+                return prev_valid();
+        }
+        iterator operator-- (int) { iterator tmp = *this; --(*this); return tmp; }
+        bool operator== (const iterator & that) const {
+                return scopes == that.scopes && level == that.level && it == that.it;
+        }
+        bool operator!= (const iterator & that) const { return !( *this == that ); }
+        size_type get_level() const { return level; }
+        Note & get_note() { return (*scopes)[level].note; }
+        const Note & get_note() const { return (*scopes)[level].note; }
+private:
+        scope_list *scopes;
+        wrapped_iterator it;
+        size_type level;
+};
+template<typename Key, typename Value, typename Note>
+class ScopedMap<Key, Value, Note>::const_iterator :
+                public std::iterator< std::bidirectional_iterator_tag, value_type > {
+        friend class ScopedMap;
+        typedef typename ScopedMap::MapType::iterator wrapped_iterator;
+        typedef typename ScopedMap::MapType::const_iterator wrapped_const_iterator;
+        typedef typename ScopedMap::ScopeList scope_list;
+        typedef typename scope_list::size_type size_type;
+        /// Checks if this iterator points to a valid item
+        bool is_valid() const {
+                return it != (*scopes)[level].map.end();
+        }
+        /// Increments on invalid
+        const_iterator & next_valid() {
+                if ( ! is_valid() ) { ++(*this); }
+                return *this;
+        }
+        /// Decrements on invalid
+        const_iterator & prev_valid() {
+                if ( ! is_valid() ) { --(*this); }
+                return *this;
+        }
+        const_iterator(scope_list const & _scopes, const wrapped_const_iterator & _it, size_type inLevel)
+                : scopes(&_scopes), it(_it), level(inLevel) {}
+public:
+        const_iterator(const iterator & that) : scopes(that.scopes), it(that.it), level(that.level) {}
+        const_iterator(const const_iterator & that) : scopes(that.scopes), it(that.it), level(that.level) {}
+        const_iterator & operator= (const iterator & that) {
+                scopes = that.scopes; level = that.level; it = that.it;
+                return *this;
+        }
+        const_iterator & operator= (const const_iterator & that) {
+                scopes = that.scopes; level = that.level; it = that.it;
+                return *this;
+        }
+        const_reference operator* () { return *it; }
+        const_pointer operator-> () { return it.operator->(); }
+        const_iterator & operator++ () {
+                if ( it == (*scopes)[level].map.end() ) {
+                        if ( level == 0 ) return *this;
+                        --level;
+                        it = (*scopes)[level].map.begin();
+                } else {
+                        ++it;
+                }
+                return next_valid();
+        }
+        const_iterator operator++ (int) { const_iterator tmp = *this; ++(*this); return tmp; }
+        const_iterator & operator-- () {
+                // may fail if this is the begin iterator; allowed by STL spec
+                if ( it == (*scopes)[level].map.begin() ) {
+                        ++level;
+                        it = (*scopes)[level].map.end();
+                }
+                --it;
+                return prev_valid();
+        }
+        const_iterator operator-- (int) { const_iterator tmp = *this; --(*this); return tmp; }
+        bool operator== (const const_iterator & that) const {
+                return scopes == that.scopes && level == that.level && it == that.it;
+        }
+        bool operator!= (const const_iterator & that) const { return !( *this == that ); }
+        size_type get_level() const { return level; }
+        const Note & get_note() const { return (*scopes)[level].note; }
+private:
+        scope_list const *scopes;
+        wrapped_const_iterator it;
+        size_type level;
 };

src/Common/SemanticError.h

-              r34b4268
+              r24d6572
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed May  4 14:08:26 2022
 // Update Count     : 35
+// Last Modified On : Sat Feb 25 12:01:31 2023
+// Update Count     : 37
 //
 …
 constexpr WarningData WarningFormats[] = {
+        {"self-assign"            , Severity::Warn    , "self assignment of expression: %s"                          },
+        {"reference-conversion"   , Severity::Warn    , "rvalue to reference conversion of rvalue: %s"               },
+        {"qualifiers-zero_t-one_t", Severity::Warn    , "questionable use of type qualifier %s with %s"              },
+        {"aggregate-forward-decl" , Severity::Warn    , "forward declaration of nested aggregate: %s"                },
+        {"superfluous-decl"       , Severity::Warn    , "declaration does not allocate storage: %s"                  },
+        {"superfluous-else"       , Severity::Warn    , "else clause never executed for empty loop conditional"      },
+        {"gcc-attributes"         , Severity::Warn    , "invalid attribute: %s"                                      },
+        {"c++-like-copy"          , Severity::Warn    , "Constructor from reference is not a valid copy constructor" },
+        {"self-assign"              , Severity::Warn    , "self assignment of expression: %s"                          },
+        {"reference-conversion"     , Severity::Warn    , "rvalue to reference conversion of rvalue: %s"               },
+        {"qualifiers-zero_t-one_t"  , Severity::Warn    , "questionable use of type qualifier(s) with %s"              },
+        {"aggregate-forward-decl"   , Severity::Warn    , "forward declaration of nested aggregate: %s"                },
+        {"superfluous-decl"         , Severity::Warn    , "declaration does not allocate storage: %s"                  },
+        {"superfluous-else"         , Severity::Warn    , "else clause never executed for empty loop conditional"      },
+        {"gcc-attributes"           , Severity::Warn    , "invalid attribute: %s"                                      },
+        {"c++-like-copy"            , Severity::Warn    , "Constructor from reference is not a valid copy constructor" },
+        {"depreciated-trait-syntax" , Severity::Warn    , "trait type-parameters are now specified using the forall clause" },
 };
 …
         GccAttributes,
         CppCopy,
+        DeprecTraitSyntax,
         NUMBER_OF_WARNINGS, // This MUST be the last warning
 };

src/Common/module.mk

-              r34b4268
+              r24d6572
         Common/CodeLocationTools.hpp \
         Common/CodeLocationTools.cpp \
-        Common/CompilerError.h \
-        Common/Debug.h \
         Common/DeclStats.hpp \
         Common/DeclStats.cpp \
         Common/ErrorObjects.h \
         Common/Eval.cc \
+        Common/Eval.h \
         Common/Examine.cc \
         Common/Examine.h \
 …
         Common/Indenter.h \
         Common/Indenter.cc \
+        Common/Iterate.hpp \
         Common/PassVisitor.cc \
         Common/PassVisitor.h \
 …
         Common/Stats/Time.cc \
         Common/Stats/Time.h \
         Common/UnimplementedError.h \
+        Common/ToString.hpp \
         Common/UniqueName.cc \
         Common/UniqueName.h \

src/Common/utility.h

-              r34b4268
+              r24d6572
 // file "LICENCE" distributed with Cforall.
 //
 // utility.h --
+// utility.h -- General utilities used across the compiler.
 //
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Andrew Beach
 // Last Modified On : Mon Apr 25 14:26:00 2022
 // Update Count     : 51
+// Last Modified On : Fri Feb 17 15:25:00 2023
+// Update Count     : 53
 //
 …
 #include <cctype>
 #include <algorithm>
-#include <functional>
 #include <iostream>
-#include <iterator>
 #include <list>
 #include <memory>
-#include <sstream>
 #include <string>
 #include <type_traits>
-#include <utility>
 #include <vector>
 #include <cstring>                                                                              // memcmp
 …
                 return 0;
         } // if
+}
-template< typename T, typename U >
-struct maybeBuild_t {
-        static T * doit( const U *orig ) {
-                if ( orig ) {
-                        return orig->build();
-                } else {
-                        return 0;
-                } // if
+        }
-};
-template< typename T, typename U >
-static inline T * maybeBuild( const U *orig ) {
-        return maybeBuild_t<T,U>::doit(orig);
+}
-template< typename T, typename U >
-static inline T * maybeMoveBuild( const U *orig ) {
-        T* ret = maybeBuild<T>(orig);
-        delete orig;
-        return ret;
+}
 …
         splice( src, dst );
         dst.swap( src );
+}
-template < typename T >
-void toString_single( std::ostream & os, const T & value ) {
-        os << value;
+}
-template < typename T, typename... Params >
-void toString_single( std::ostream & os, const T & value, const Params & ... params ) {
-        os << value;
-        toString_single( os, params ... );
+}
-template < typename ... Params >
-std::string toString( const Params & ... params ) {
-        std::ostringstream os;
-        toString_single( os, params... );
-        return os.str();
+}
-#define toCString( ... ) toString( __VA_ARGS__ ).c_str()
-// replace element of list with all elements of another list
-template< typename T >
-void replace( std::list< T > &org, typename std::list< T >::iterator pos, std::list< T > &with ) {
-        typename std::list< T >::iterator next = pos; advance( next, 1 );
-        //if ( next != org.end() ) {
-        org.erase( pos );
-        org.splice( next, with );
-        //}
-        return;
+}
-// replace range of a list with a single element
-template< typename T >
-void replace( std::list< T > &org, typename std::list< T >::iterator begin, typename std::list< T >::iterator end, const T & with ) {
-        org.insert( begin, with );
-        org.erase( begin, end );
+}
 …
+}
-template< typename... Args >
-auto zip(Args&&... args) -> decltype(zipWith(std::forward<Args>(args)..., std::make_pair)) {
-  return zipWith(std::forward<Args>(args)..., std::make_pair);
+}
-template< class InputIterator1, class InputIterator2, class OutputIterator, class BinFunction >
-void zipWith( InputIterator1 b1, InputIterator1 e1, InputIterator2 b2, InputIterator2 e2, OutputIterator out, BinFunction func ) {
-        while ( b1 != e1 && b2 != e2 )
-                *out++ = func(*b1++, *b2++);
+}
-// it's nice to actually be able to increment iterators by an arbitrary amount
-template< class InputIt, class Distance >
-InputIt operator+( InputIt it, Distance n ) {
-        advance(it, n);
-        return it;
+}
-template< typename T >
-void warn_single( const T & arg ) {
-        std::cerr << arg << std::endl;
+}
-template< typename T, typename... Params >
-void warn_single(const T & arg, const Params & ... params ) {
-        std::cerr << arg;
-        warn_single( params... );
+}
-template< typename... Params >
-void warn( const Params & ... params ) {
-        std::cerr << "Warning: ";
-        warn_single( params... );
+}
 // determines if pref is a prefix of str
 static inline bool isPrefix( const std::string & str, const std::string & pref, unsigned int start = 0 ) {
         if ( pref.size() > str.size() ) return false;
+    return 0 == memcmp( str.c_str() + start, pref.c_str(), pref.size() );
+        // return prefix == full.substr(0, prefix.size()); // for future, requires c++17
+}
+// -----------------------------------------------------------------------------
+// Ref Counted Singleton class
+// Objects that inherit from this class will have at most one reference to it
+// but if all references die, the object will be deleted.
+template< typename ThisType >
+class RefCountSingleton {
+  public:
+        static std::shared_ptr<ThisType> get() {
+                if( global_instance.expired() ) {
+                        std::shared_ptr<ThisType> new_instance = std::make_shared<ThisType>();
+                        global_instance = new_instance;
+                        return std::move(new_instance);
+                }
+                return global_instance.lock();
+        }
+  private:
+        static std::weak_ptr<ThisType> global_instance;
+};
+template< typename ThisType >
+std::weak_ptr<ThisType> RefCountSingleton<ThisType>::global_instance;
+        return pref == str.substr(start, pref.size());
+}
 // -----------------------------------------------------------------------------
 …
         ~ValueGuardPtr() { if( ref ) { swap( *ref, old ); } }
 };
-// -----------------------------------------------------------------------------
-// Helper struct and function to support
-// for ( val : reverseIterate( container ) ) {}
-// syntax to have a for each that iterates backwards
-template< typename T >
-struct reverse_iterate_t {
-        T& ref;
-        reverse_iterate_t( T & ref ) : ref(ref) {}
-        // this does NOT work on const T!!!
-        // typedef typename T::reverse_iterator iterator;
-        auto begin() { return ref.rbegin(); }
-        auto end() { return ref.rend(); }
-};
-template< typename T >
-reverse_iterate_t< T > reverseIterate( T & ref ) {
-        return reverse_iterate_t< T >( ref );
+}
-template< typename T >
-struct enumerate_t {
-        template<typename val_t>
-        struct value_t {
-                val_t & val;
-                size_t idx;
-        };
-        template< typename iter_t, typename val_t >
-        struct iterator_t {
-                iter_t it;
-                size_t idx;
-                iterator_t( iter_t _it, size_t _idx ) : it(_it), idx(_idx) {}
-                value_t<val_t> operator*() const { return value_t<val_t>{ *it, idx }; }
-                bool operator==(const iterator_t & o) const { return o.it == it; }
-                bool operator!=(const iterator_t & o) const { return o.it != it; }
-                iterator_t & operator++() {
-                        it++;
-                        idx++;
-                        return *this;
+                }
-                using difference_type   = typename std::iterator_traits< iter_t >::difference_type;
-                using value_type        = value_t<val_t>;
-                using pointer           = value_t<val_t> *;
-                using reference         = value_t<val_t> &;
-                using iterator_category = std::forward_iterator_tag;
-        };
-        T & ref;
-        using iterator = iterator_t< typename T::iterator, typename T::value_type >;
-        using const_iterator = iterator_t< typename T::const_iterator, const typename T::value_type >;
-        iterator begin() { return iterator( ref.begin(), 0 ); }
-        iterator end()   { return iterator( ref.end(), ref.size() ); }
-        const_iterator begin() const { return const_iterator( ref.cbegin(), 0 ); }
-        const_iterator end()   const { return const_iterator( ref.cend(), ref.size() ); }
-        const_iterator cbegin() const { return const_iterator( ref.cbegin(), 0 ); }
-        const_iterator cend()   const { return const_iterator( ref.cend(), ref.size() ); }
-};
-template< typename T >
-enumerate_t<T> enumerate( T & ref ) {
-        return enumerate_t< T >{ ref };
+}
-template< typename T >
-const enumerate_t< const T > enumerate( const T & ref ) {
-        return enumerate_t< const T >{ ref };
+}
-template< typename OutType, typename Range, typename Functor >
-OutType map_range( const Range& range, Functor&& functor ) {
-        OutType out;
-        std::transform(
-                begin( range ),
-                end( range ),
-                std::back_inserter( out ),
-                std::forward< Functor >( functor )
-        );
-        return out;
+}
-// -----------------------------------------------------------------------------
-// Helper struct and function to support:
-// for ( auto val : group_iterate( container1, container2, ... ) ) { ... }
-// This iteraters through multiple containers of the same size.
-template<typename... Args>
-class group_iterate_t {
-        using Iterables = std::tuple<Args...>;
-        Iterables iterables;
-        // Getting the iterator and value types this way preserves const.
-        template<size_t I> using Iter = decltype(std::get<I>(iterables).begin());
-        template<size_t I> using Data = decltype(*std::get<I>(iterables).begin());
-        template<typename> struct base_iterator;
-        // This inner template puts the sequence of `0, 1, ... sizeof...(Args)-1`
-        // into a pack. These are the indexes into the tuples, so unpacking can
-        // go over each element of the tuple.
-        // The std::integer_sequence is just used to build that sequence.
-        // A library reference will probably explain it better than I can.
-        template<std::size_t... Indices>
-        struct base_iterator<std::integer_sequence<std::size_t, Indices...>> {
-                using value_type = std::tuple< Data<Indices>... >;
-                std::tuple<Iter<Indices>...> iterators;
-                base_iterator( Iter<Indices>... is ) : iterators( is... ) {}
-                base_iterator operator++() {
-                        return base_iterator( ++std::get<Indices>( iterators )... );
+                }
-                bool operator!=( const base_iterator& other ) const {
-                        return iterators != other.iterators;
+                }
-                value_type operator*() const {
-                        return std::tie( *std::get<Indices>( iterators )... );
+                }
-                static base_iterator make_begin( Iterables & data ) {
-                        return base_iterator( std::get<Indices>( data ).begin()... );
+                }
-                static base_iterator make_end( Iterables & data ) {
-                        return base_iterator( std::get<Indices>( data ).end()... );
+                }
-        };
-public:
-        group_iterate_t( const Args &... args ) : iterables( args... ) {}
-        using iterator = base_iterator<decltype(
-                std::make_integer_sequence<std::size_t, sizeof...(Args)>())>;
-        iterator begin() { return iterator::make_begin( iterables ); }
-        iterator end() { return iterator::make_end( iterables ); }
-};
-// Helpers for the bounds checks (the non-varatic part of group_iterate):
-static inline void runGroupBoundsCheck(size_t size0, size_t size1) {
-        assertf( size0 == size1,
-                "group iteration requires containers of the same size: <%zd, %zd>.",
-                size0, size1 );
+}
-static inline void runGroupBoundsCheck(size_t size0, size_t size1, size_t size2) {
-        assertf( size0 == size1 && size1 == size2,
-                "group iteration requires containers of the same size: <%zd, %zd, %zd>.",
-                size0, size1, size2 );
+}
-/// Performs bounds check to ensure that all arguments are of the same length.
-template< typename... Args >
-group_iterate_t<Args...> group_iterate( Args &&... args ) {
-        runGroupBoundsCheck( args.size()... );
-        return group_iterate_t<Args...>( std::forward<Args>( args )... );
+}
-/// Does not perform a bounds check - requires user to ensure that iteration terminates when appropriate.
-template< typename... Args >
-group_iterate_t<Args...> unsafe_group_iterate( Args &&... args ) {
-        return group_iterate_t<Args...>( std::forward<Args>( args )... );
+}
-// -----------------------------------------------------------------------------
-// Helper struct and function to support
-// for ( val : lazy_map( container1, f ) ) {}
-// syntax to have a for each that iterates a container, mapping each element by applying f
-template< typename T, typename Func >
-struct lambda_iterate_t {
-        const T & ref;
-        std::function<Func> f;
-        struct iterator {
-                typedef decltype(begin(ref)) Iter;
-                Iter it;
-                std::function<Func> f;
-                iterator( Iter it, std::function<Func> f ) : it(it), f(f) {}
-                iterator & operator++() {
-                        ++it; return *this;
+                }
-                bool operator!=( const iterator &other ) const { return it != other.it; }
-                auto operator*() const -> decltype(f(*it)) { return f(*it); }
-        };
-        lambda_iterate_t( const T & ref, std::function<Func> f ) : ref(ref), f(f) {}
-        auto begin() const -> decltype(iterator(std::begin(ref), f)) { return iterator(std::begin(ref), f); }
-        auto end() const   -> decltype(iterator(std::end(ref), f)) { return iterator(std::end(ref), f); }
-};
-template< typename... Args >
-lambda_iterate_t<Args...> lazy_map( const Args &... args ) {
-        return lambda_iterate_t<Args...>( args...);
+}
 // -----------------------------------------------------------------------------
 …
 } // ilog2
-// -----------------------------------------------------------------------------
-/// evaluates expr as a long long int. If second is false, expr could not be evaluated
-std::pair<long long int, bool> eval(const 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;
-/// 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 ) {
-                if ( lt( *i, *min_pos ) ) {
-                        // new minimum cost; swap into first position
-                        min_pos = begin;
-                        std::iter_swap( min_pos, i );
-                } else if ( ! lt( *min_pos, *i ) ) {
-                        // duplicate minimum cost; swap into next minimum position
-                        ++min_pos;
-                        std::iter_swap( min_pos, i );
+                }
+        }
-        return ++min_pos;
+}
-template<typename Iter, typename Compare>
-inline Iter sort_mins( Iter begin, Iter end, Compare&& lt ) {
-        return sort_mins( begin, end, lt );
+}
-/// sort_mins defaulted to use std::less
-template<typename Iter>
-inline Iter sort_mins( Iter begin, Iter end ) {
-        return sort_mins( begin, end, std::less<typename std::iterator_traits<Iter>::value_type>{} );
+}
 // Local Variables: //
 // tab-width: 4 //

src/CompilationState.cc

-              r34b4268
+              r24d6572
 // Author           : Rob Schluntz
 // Created On       : Mon Ju1 30 10:47:01 2018
 // Last Modified By : Henry Xue
 // Last Modified On : Tue Jul 20 04:27:35 2021
 // Update Count     : 5
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Mon Apr 10 19:12:50 2023
+// Update Count     : 6
 //
 …
         expraltp = false,
         genericsp = false,
+        invariant = false,
         libcfap = false,
         nopreludep = false,
 …
         useNewAST = true,
         nomainp = false,
-        parsep = false,
         resolvep = false,
         resolvprotop = false,

src/CompilationState.h

-              r34b4268
+              r24d6572
 // Author           : Rob Schluntz
 // Created On       : Mon Ju1 30 10:47:01 2018
 // Last Modified By : Henry Xue
 // Last Modified On : Tue Jul 20 04:27:35 2021
 // Update Count     : 5
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Mon Apr 10 19:12:53 2023
+// Update Count     : 6
 //
 …
         expraltp,
         genericsp,
+        invariant,
         libcfap,
         nopreludep,
 …
         useNewAST,
         nomainp,
-        parsep,
         resolvep,
         resolvprotop,

src/Concurrency/KeywordsNew.cpp

r34b4268	r24d6572
779	779
780	780	const ast::Stmt * SuspendKeyword::postvisit( const ast::SuspendStmt * stmt ) {
781		switch ( stmt->~~type~~ ) {
	781	switch ( stmt->kind ) {
782	782	case ast::SuspendStmt::None:
783	783	// Use the context to determain the implicit target.

src/Concurrency/WaitforNew.cpp

-              r34b4268
+              r24d6572
         const ast::VariableExpr * variableExpr =
                 clause->target_func.as<ast::VariableExpr>();
+                clause->target.as<ast::VariableExpr>();
         ast::Expr * castExpr = new ast::CastExpr(
                 location,
                 new ast::CastExpr(
                         location,
                         clause->target_func,
+                        clause->target,
                         ast::deepCopy( variableExpr->result.get() ),
                         ast::GeneratedCast ),
 …
         ResolveContext context{ symtab, transUnit().global };
         out->push_back( maybeCond( location, clause->cond.get(), {
+        out->push_back( maybeCond( location, clause->when_cond.get(), {
                 makeAccStmt( location, acceptables, index, "is_dtor",
                         detectIsDtor( location, clause->target_func ), context ),
+                        detectIsDtor( location, clause->target ), context ),
                 makeAccStmt( location, acceptables, index, "func",
                         funcExpr, context ),

src/Concurrency/module.mk

-              r34b4268
+              r24d6572
 SRC += \
+        Concurrency/Actors.cpp \
+        Concurrency/Actors.hpp \
         Concurrency/KeywordsNew.cpp \
         Concurrency/Keywords.cc \
 …
         Concurrency/WaitforNew.cpp \
         Concurrency/Waitfor.cc \
+        Concurrency/Waitfor.h
+        Concurrency/Waitfor.h \
+        Concurrency/Waituntil.cpp \
+        Concurrency/Waituntil.hpp

src/ControlStruct/ExceptDeclNew.cpp

-              r34b4268
+              r24d6572
 #include "ExceptDecl.h"
+#include <sstream>
+#include "AST/Copy.hpp"
 #include "AST/Decl.hpp"
 #include "AST/Pass.hpp"

src/ControlStruct/ExceptTranslateNew.cpp

-              r34b4268
+              r24d6572
                 nullptr,
                 ast::Storage::Classes{},
+                ast::Linkage::Cforall
+                ast::Linkage::Cforall,
+                {},
+                { ast::Function::Inline }
         );
+}

src/ControlStruct/MLEMutator.cc

r34b4268	r24d6572
25	25	#include <memory> // for allocator_traits<>::value_...
26	26
27		#include "Common/~~utility.h" // for toString, operator+~~
	27	#include "Common/ToString.hpp" // for toString
28	28	#include "ControlStruct/LabelGenerator.h" // for LabelGenerator
29	29	#include "MLEMutator.h"

src/GenPoly/Box.cc

-              r34b4268
+              r24d6572
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Dec 13 23:40:34 2019
 // Update Count     : 347
+// Last Modified By : Andrew Beach
+// Last Modified On : Mon Dec 19 16:36:00 2022
+// Update Count     : 348
 //
+#include "Box.h"
 #include <algorithm>                     // for mismatch
 …
 #include <utility>                       // for pair
-#include "Box.h"
 #include "CodeGen/OperatorTable.h"
 #include "Common/PassVisitor.h"          // for PassVisitor
 …
 #include "Common/SemanticError.h"        // for SemanticError
 #include "Common/UniqueName.h"           // for UniqueName
 #include "Common/utility.h"              // for toString
+#include "Common/ToString.hpp"           // for toCString
 #include "FindFunction.h"                // for findFunction, findAndReplace...
 #include "GenPoly/ErasableScopedMap.h"   // for ErasableScopedMap<>::const_i...
 …
 #include "InitTweak/InitTweak.h"         // for getFunctionName, isAssignment
 #include "Lvalue.h"                      // for generalizedLvalue
 #include "ResolvExpr/typeops.h"          // for typesCompatible
+#include "ResolvExpr/Unify.h"            // for typesCompatible
 #include "ScopedSet.h"                   // for ScopedSet, ScopedSet<>::iter...
 #include "ScrubTyVars.h"                 // for ScrubTyVars
 …
                 };
+                /// Updates the call sites of polymorphic functions.
                 /// Replaces polymorphic return types with out-parameters,
                 /// replaces calls to polymorphic functions with adapter calls,
                 /// 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 CallAdapter final : public BoxPass, public WithConstTypeSubstitution, public WithStmtsToAdd, public WithGuards, public WithVisitorRef<CallAdapter>, public WithShortCircuiting {
                   public:
+                        Pass1();
+                        CallAdapter();
+                        void premutate( Declaration * declaration );
                         void premutate( FunctionDecl * functionDecl );
                         void premutate( TypeDecl * typeDecl );
 …
                 };
+                /// Updates declarations (and types) that require adapters.
                 /// * Moves polymorphic returns in function types to pointer-type parameters
                 /// * adds type size and assertion parameters to parameter lists
                 struct Pass2 final : public BoxPass, public WithGuards {
+                struct DeclAdapter final : public BoxPass, public WithGuards {
                         void handleAggDecl();
 …
                 };
+                /// Erases unneeded/unwanted polymorphic information.
                 /// Replaces initialization of polymorphic values with alloca,
                 /// declaration of dtype/ftype with appropriate void expression,
                 /// sizeof expressions of polymorphic types with the proper variable,
                 /// and strips fields from generic struct declarations.
+                struct Pass3 final : public BoxPass, public WithGuards {
+                        template< typename DeclClass >
+                        void handleDecl( DeclClass * decl, Type * type );
+                struct Eraser final {
                         void premutate( ObjectDecl * objectDecl );
                         void premutate( FunctionDecl * functionDecl );
 …
                         void premutate( StructDecl * structDecl );
                         void premutate( UnionDecl * unionDecl );
-                        void premutate( TypeDecl * typeDecl );
-                        void premutate( PointerType * pointerType );
-                        void premutate( FunctionType * funcType );
                 };
         } // anonymous namespace
 …
         void box( std::list< Declaration *>& translationUnit ) {
                 PassVisitor<LayoutFunctionBuilder> layoutBuilder;
                 PassVisitor<Pass1> pass1;
                 PassVisitor<Pass2> pass2;
+                PassVisitor<CallAdapter> callAdapter;
+                PassVisitor<DeclAdapter> declAdapter;
                 PassVisitor<PolyGenericCalculator> polyCalculator;
                 PassVisitor<Pass3> pass3;
+                PassVisitor<Eraser> eraser;
                 acceptAll( translationUnit, layoutBuilder );
                 mutateAll( translationUnit, pass1 );
                 mutateAll( translationUnit, pass2 );
+                mutateAll( translationUnit, callAdapter );
+                mutateAll( translationUnit, declAdapter );
                 mutateAll( translationUnit, polyCalculator );
                 mutateAll( translationUnit, pass3 );
+                mutateAll( translationUnit, eraser );
+        }
         ////////////////////////////////// LayoutFunctionBuilder ////////////////////////////////////////////
+////////////////////////////////// LayoutFunctionBuilder ////////////////////////////////////////
         /// Get a list of type declarations that will affect a layout function
 …
+        }
         ////////////////////////////////////////// Pass1 ////////////////////////////////////////////////////
+////////////////////////////////////////////// CallAdapter //////////////////////////////////////
         namespace {
                 std::string makePolyMonoSuffix( FunctionType const * function, const TyVarMap &tyVars ) {
-                        std::stringstream name;
                         // NOTE: this function previously used isPolyObj, which failed to produce
                         // the correct thing in some situations. It's not clear to me why this wasn't working.
 …
                         // to take those polymorphic types as pointers. Therefore, there can be two different functions
                         // with the same mangled name, so we need to further mangle the names.
+                        std::stringstream name;
                         for ( DeclarationWithType const * const ret : function->returnVals ) {
+                                if ( isPolyType( ret->get_type(), tyVars ) ) {
+                                        name << "P";
+                                } else {
+                                        name << "M";
+                                }
+                        }
+                        name << "_";
+                                name << ( isPolyType( ret->get_type(), tyVars ) ? 'P' : 'M' );
+                        }
+                        name << '_';
                         for ( DeclarationWithType const * const arg : function->parameters ) {
+                                if ( isPolyType( arg->get_type(), tyVars ) ) {
+                                        name << "P";
+                                } else {
+                                        name << "M";
+                                }
+                        } // for
+                                name << ( isPolyType( arg->get_type(), tyVars ) ? 'P' : 'M' );
+                        }
                         return name.str();
+                }
 …
                 Type *replaceWithConcrete( Type *type, TypeSubstitution const * env, bool doClone = true );
+                Pass1::Pass1() : tempNamer( "_temp" ) {}
+                void Pass1::premutate( FunctionDecl *functionDecl ) {
+                CallAdapter::CallAdapter() : tempNamer( "_temp" ) {}
+                void CallAdapter::premutate( Declaration * ) {
+                        // Prevent type declaration information from leaking out.
+                        GuardScope( scopeTyVars );
+                }
+                void CallAdapter::premutate( FunctionDecl *functionDecl ) {
                         if ( functionDecl->get_statements() ) {         // empty routine body ?
                                 // std::cerr << "mutating function: " << functionDecl->get_mangleName() << std::endl;
 …
                                 for ( FunctionType const * const funType : functions ) {
                                         std::string mangleName = mangleAdapterName( funType, scopeTyVars );
                                         if ( adapters.find( mangleName ) == adapters.end() ) {
+                                        if ( !adapters.contains( mangleName ) ) {
                                                 std::string adapterName = makeAdapterName( mangleName );
                                                 adapters.insert( std::pair< std::string, DeclarationWithType *>( mangleName, new ObjectDecl( adapterName, Type::StorageClasses(), LinkageSpec::C, nullptr, new PointerType( Type::Qualifiers(), makeAdapterType( funType, scopeTyVars ) ), nullptr ) ) );
 …
+                }
                 void Pass1::premutate( TypeDecl *typeDecl ) {
+                void CallAdapter::premutate( TypeDecl *typeDecl ) {
                         addToTyVarMap( typeDecl, scopeTyVars );
+                }
                 void Pass1::premutate( CommaExpr *commaExpr ) {
+                void CallAdapter::premutate( CommaExpr *commaExpr ) {
                         // Attempting to find application expressions that were mutated by the copy constructor passes
                         // to use an explicit return variable, so that the variable can be reused as a parameter to the
 …
+                }
                 std::list< Expression *>::iterator Pass1::passArgTypeVars( ApplicationExpr *appExpr, Type *parmType, Type *argBaseType, std::list< Expression *>::iterator arg, const TyVarMap &exprTyVars, std::set< std::string > &seenTypes ) {
+                std::list< Expression *>::iterator CallAdapter::passArgTypeVars( ApplicationExpr *appExpr, Type *parmType, Type *argBaseType, std::list< Expression *>::iterator arg, const TyVarMap &exprTyVars, std::set< std::string > &seenTypes ) {
                         Type *polyType = isPolyType( parmType, exprTyVars );
                         if ( polyType && ! dynamic_cast< TypeInstType* >( polyType ) ) {
 …
+                }
                 std::list< Expression *>::iterator Pass1::passTypeVars( ApplicationExpr *appExpr, Type *polyRetType, const TyVarMap &exprTyVars ) {
+                std::list< Expression *>::iterator CallAdapter::passTypeVars( ApplicationExpr *appExpr, Type *polyRetType, const TyVarMap &exprTyVars ) {
                         assert( env );
                         std::list< Expression *>::iterator arg = appExpr->args.begin();
 …
                         // even when converted to strings, sort in the original order.
                         // (At least, that is the best explination I have.)
                         for ( std::pair<std::string, TypeDecl::Data> const & tyParam : exprTyVars ) {
+                        for ( std::pair<const std::string, TypeDecl::Data> const & tyParam : exprTyVars ) {
                                 if ( !tyParam.second.isComplete ) continue;
                                 Type *concrete = env->lookup( tyParam.first );
 …
+                }
                 ObjectDecl *Pass1::makeTemporary( Type *type ) {
+                ObjectDecl *CallAdapter::makeTemporary( Type *type ) {
                         ObjectDecl *newObj = new ObjectDecl( tempNamer.newName(), Type::StorageClasses(), LinkageSpec::C, 0, type, 0 );
                         stmtsToAddBefore.push_back( new DeclStmt( newObj ) );
 …
+                }
                 Expression *Pass1::addRetParam( ApplicationExpr *appExpr, Type *retType ) {
+                Expression *CallAdapter::addRetParam( ApplicationExpr *appExpr, Type *retType ) {
                         // Create temporary to hold return value of polymorphic function and produce that temporary as a result
                         // using a comma expression.
 …
+                }
                 Expression *Pass1::addDynRetParam( ApplicationExpr *appExpr, Type *dynType ) {
+                Expression *CallAdapter::addDynRetParam( ApplicationExpr *appExpr, Type *dynType ) {
                         Type *concrete = replaceWithConcrete( dynType, env );
                         // add out-parameter for return value
 …
+                }
                 Expression *Pass1::applyAdapter( ApplicationExpr *appExpr, FunctionType *function ) {
+                Expression *CallAdapter::applyAdapter( ApplicationExpr *appExpr, FunctionType *function ) {
                         Expression *ret = appExpr;
                         if ( isDynRet( function, scopeTyVars ) ) {
 …
+                }
                 void Pass1::boxParam( Expression *&arg, Type *param, const TyVarMap &exprTyVars ) {
+                void CallAdapter::boxParam( Expression *&arg, Type *param, const TyVarMap &exprTyVars ) {
                         assertf( arg->result, "arg does not have result: %s", toString( arg ).c_str() );
                         addCast( arg, param, exprTyVars );
 …
+                }
                 void Pass1::boxParams( ApplicationExpr *appExpr, std::list< Expression *>::iterator arg, FunctionType *function, const TyVarMap &exprTyVars ) {
+                void CallAdapter::boxParams( ApplicationExpr *appExpr, std::list< Expression *>::iterator arg, FunctionType *function, const TyVarMap &exprTyVars ) {
                         for ( DeclarationWithType * param : function->parameters ) {
                                 assertf( arg != appExpr->args.end(), "boxParams: missing argument for param %s to %s in %s", toString( param ).c_str(), toString( function ).c_str(), toString( appExpr ).c_str() );
 …
+                }
                 void Pass1::addInferredParams( ApplicationExpr *appExpr, std::list< Expression *>::iterator arg, FunctionType *functionType, const TyVarMap &tyVars ) {
+                void CallAdapter::addInferredParams( ApplicationExpr *appExpr, std::list< Expression *>::iterator arg, FunctionType *functionType, const TyVarMap &tyVars ) {
                         for ( TypeDecl * const tyVar : functionType->forall ) {
                                 for ( DeclarationWithType * const assert : tyVar->assertions ) {
 …
+                }
                 FunctionDecl *Pass1::makeAdapter( FunctionType const *adaptee, FunctionType *realType, const std::string &mangleName, const TyVarMap &tyVars ) {
+                FunctionDecl *CallAdapter::makeAdapter( FunctionType const *adaptee, FunctionType *realType, const std::string &mangleName, const TyVarMap &tyVars ) {
                         FunctionType *adapterType = makeAdapterType( adaptee, tyVars );
                         adapterType = ScrubTyVars::scrub( adapterType, tyVars );
 …
+                }
                 void Pass1::passAdapters( ApplicationExpr * appExpr, FunctionType * functionType, const TyVarMap & exprTyVars ) {
+                void CallAdapter::passAdapters( ApplicationExpr * appExpr, FunctionType * functionType, const TyVarMap & exprTyVars ) {
                         // collect a list of function types passed as parameters or implicit parameters (assertions)
                         std::list<FunctionType const *> functions;
 …
                         for ( FunctionType const * const funType : functions ) {
+                                FunctionType *originalFunction = funType->clone();
+                                FunctionType *realFunction = funType->clone();
+                                std::string mangleName = SymTab::Mangler::mangle( realFunction );
+                                std::string mangleName = SymTab::Mangler::mangle( funType );
                                 // only attempt to create an adapter or pass one as a parameter if we haven't already done so for this
                                 // pre-substitution parameter function type.
                                 // The second part of the insert result is "is the value new".
+                                if ( adaptersDone.insert( mangleName ).second ) {
+                                        // apply substitution to type variables to figure out what the adapter's type should look like
+                                        assert( env );
+                                        env->apply( realFunction );
+                                        mangleName = SymTab::Mangler::mangle( realFunction );
+                                        mangleName += makePolyMonoSuffix( originalFunction, exprTyVars );
+                                        typedef ScopedMap< std::string, DeclarationWithType* >::iterator AdapterIter;
+                                        AdapterIter adapter = adapters.find( mangleName );
+                                        if ( adapter == adapters.end() ) {
+                                                // adapter has not been created yet in the current scope, so define it
+                                                FunctionDecl *newAdapter = makeAdapter( funType, realFunction, mangleName, exprTyVars );
+                                                std::pair< AdapterIter, bool > answer = adapters.insert( std::pair< std::string, DeclarationWithType *>( mangleName, newAdapter ) );
+                                                adapter = answer.first;
+                                                stmtsToAddBefore.push_back( new DeclStmt( newAdapter ) );
+                                        } // if
+                                        assert( adapter != adapters.end() );
+                                        // add the appropriate adapter as a parameter
+                                        appExpr->get_args().push_front( new VariableExpr( adapter->second ) );
+                                if ( !adaptersDone.insert( mangleName ).second ) continue;
+                                // Apply substitution to type variables to figure out what the adapter's type should look like.
+                                assert( env );
+                                FunctionType *realType = funType->clone();
+                                env->apply( realType );
+                                mangleName = SymTab::Mangler::mangle( realType );
+                                mangleName += makePolyMonoSuffix( funType, exprTyVars );
+                                typedef ScopedMap< std::string, DeclarationWithType* >::iterator AdapterIter;
+                                AdapterIter adapter = adapters.find( mangleName );
+                                if ( adapter == adapters.end() ) {
+                                        // Adapter has not been created yet in the current scope, so define it.
+                                        FunctionDecl *newAdapter = makeAdapter( funType, realType, mangleName, exprTyVars );
+                                        std::pair< AdapterIter, bool > answer = adapters.insert( mangleName, newAdapter );
+                                        adapter = answer.first;
+                                        stmtsToAddBefore.push_back( new DeclStmt( newAdapter ) );
                                 } // if
+                                assert( adapter != adapters.end() );
+                                // Add the appropriate adapter as a parameter.
+                                appExpr->args.push_front( new VariableExpr( adapter->second ) );
                         } // for
                 } // passAdapters
 …
+                }
                 Expression *Pass1::handleIntrinsics( ApplicationExpr *appExpr ) {
+                Expression *CallAdapter::handleIntrinsics( ApplicationExpr *appExpr ) {
                         if ( VariableExpr *varExpr = dynamic_cast< VariableExpr *>( appExpr->function ) ) {
                                 if ( varExpr->var->linkage == LinkageSpec::Intrinsic ) {
 …
+                }
                 Expression *Pass1::postmutate( ApplicationExpr *appExpr ) {
+                Expression *CallAdapter::postmutate( ApplicationExpr *appExpr ) {
                         // std::cerr << "mutate appExpr: " << InitTweak::getFunctionName( appExpr ) << std::endl;
                         // for ( auto tyVar : scopeTyVars ) {
 …
+                }
                 Expression * Pass1::postmutate( UntypedExpr *expr ) {
+                Expression * CallAdapter::postmutate( UntypedExpr *expr ) {
                         if ( isPolyDeref( expr, scopeTyVars, env ) ) {
                                 Expression *ret = expr->args.front();
 …
+                }
                 void Pass1::premutate( AddressExpr * ) { visit_children = false; }
                 Expression * Pass1::postmutate( AddressExpr * addrExpr ) {
+                void CallAdapter::premutate( AddressExpr * ) { visit_children = false; }
+                Expression * CallAdapter::postmutate( AddressExpr * addrExpr ) {
                         assert( addrExpr->arg->result && ! addrExpr->arg->result->isVoid() );
 …
+                }
                 void Pass1::premutate( ReturnStmt *returnStmt ) {
+                void CallAdapter::premutate( ReturnStmt *returnStmt ) {
                         if ( retval && returnStmt->expr ) {
                                 assert( returnStmt->expr->result && ! returnStmt->expr->result->isVoid() );
 …
+                }
                 void Pass1::premutate( PointerType *pointerType ) {
+                void CallAdapter::premutate( PointerType *pointerType ) {
                         GuardScope( scopeTyVars );
                         makeTyVarMap( pointerType, scopeTyVars );
+                }
                 void Pass1::premutate( FunctionType *functionType ) {
+                void CallAdapter::premutate( FunctionType *functionType ) {
                         GuardScope( scopeTyVars );
                         makeTyVarMap( functionType, scopeTyVars );
+                }
                 void Pass1::beginScope() {
+                void CallAdapter::beginScope() {
                         adapters.beginScope();
+                }
                 void Pass1::endScope() {
+                void CallAdapter::endScope() {
                         adapters.endScope();
+                }
 ////////////////////////////////////////// Pass2 ////////////////////////////////////////////////////
                 void Pass2::addAdapters( FunctionType *functionType ) {
+////////////////////////////////////////// DeclAdapter //////////////////////////////////////////
+                void DeclAdapter::addAdapters( FunctionType *functionType ) {
                         std::list< FunctionType const *> functions;
                         for ( DeclarationWithType * const arg : functionType->parameters ) {
 …
+                }
                 DeclarationWithType * Pass2::postmutate( FunctionDecl *functionDecl ) {
+                DeclarationWithType * DeclAdapter::postmutate( FunctionDecl *functionDecl ) {
                         FunctionType * ftype = functionDecl->type;
                         if ( ! ftype->returnVals.empty() && functionDecl->statements ) {
 …
+                }
                 void Pass2::premutate( StructDecl * ) {
+                void DeclAdapter::premutate( StructDecl * ) {
                         // prevent tyVars from leaking into containing scope
                         GuardScope( scopeTyVars );
+                }
                 void Pass2::premutate( UnionDecl * ) {
+                void DeclAdapter::premutate( UnionDecl * ) {
                         // prevent tyVars from leaking into containing scope
                         GuardScope( scopeTyVars );
+                }
                 void Pass2::premutate( TraitDecl * ) {
+                void DeclAdapter::premutate( TraitDecl * ) {
                         // prevent tyVars from leaking into containing scope
                         GuardScope( scopeTyVars );
+                }
                 void Pass2::premutate( TypeDecl *typeDecl ) {
+                void DeclAdapter::premutate( TypeDecl *typeDecl ) {
                         addToTyVarMap( typeDecl, scopeTyVars );
+                }
                 void Pass2::premutate( PointerType *pointerType ) {
+                void DeclAdapter::premutate( PointerType *pointerType ) {
                         GuardScope( scopeTyVars );
                         makeTyVarMap( pointerType, scopeTyVars );
+                }
                 void Pass2::premutate( FunctionType *funcType ) {
+                void DeclAdapter::premutate( FunctionType *funcType ) {
                         GuardScope( scopeTyVars );
                         makeTyVarMap( funcType, scopeTyVars );
 …
+                }
 ////////////////////////////////////////// PolyGenericCalculator ////////////////////////////////////////////////////
+////////////////////////////////////////// PolyGenericCalculator ////////////////////////////////
                 PolyGenericCalculator::PolyGenericCalculator()
 …
                         // make sure that any type information passed into the function is accounted for
                         for ( DeclarationWithType * const fnParam : funcType->get_parameters() ) {
                                 // condition here duplicates that in Pass2::mutate( FunctionType* )
+                                // condition here duplicates that in DeclAdapter::mutate( FunctionType* )
                                 Type *polyType = isPolyType( fnParam->get_type(), scopeTyVars );
                                 if ( polyType && ! dynamic_cast< TypeInstType* >( polyType ) ) {
 …
                                         if ( TypeInstType *typeInst = dynamic_cast< TypeInstType* >( ty ) ) {
                                                 // do not try to monomorphize generic parameters
                                                 if ( scopeTyVars.find( typeInst->get_name() ) != scopeTyVars.end() && ! genericParams.count( typeInst->name ) ) {
+                                                if ( scopeTyVars.contains( typeInst->get_name() ) && ! genericParams.count( typeInst->name ) ) {
                                                         // polymorphic aggregate members should be converted into monomorphic members.
                                                         // Using char[size_T] here respects the expected sizing rules of an aggregate type.
 …
                         if ( auto typeInst = dynamic_cast< TypeInstType const * >( ty ) ) {
                                 if ( scopeTyVars.find( typeInst->get_name() ) != scopeTyVars.end() ) {
+                                if ( scopeTyVars.contains( typeInst->get_name() ) ) {
                                         // NOTE assumes here that getting put in the scopeTyVars included having the layout variables set
                                         return true;
 …
                                 // check if this type already has a layout generated for it
                                 std::string typeName = mangleType( ty );
                                 if ( knownLayouts.find( typeName ) != knownLayouts.end() ) return true;
+                                if ( knownLayouts.contains( typeName ) ) return true;
                                 // check if any of the type parameters have dynamic layout; if none do, this type is (or will be) monomorphized
 …
                                 // check if this type already has a layout generated for it
                                 std::string typeName = mangleType( ty );
                                 if ( knownLayouts.find( typeName ) != knownLayouts.end() ) return true;
+                                if ( knownLayouts.contains( typeName ) ) return true;
                                 // check if any of the type parameters have dynamic layout; if none do, this type is (or will be) monomorphized
 …
                         } else {
                                 std::string offsetName = offsetofName( mangleType( ty ) );
                                 if ( knownOffsets.find( offsetName ) != knownOffsets.end() ) {
+                                if ( knownOffsets.contains( offsetName ) ) {
                                         // use the already-generated offsets for this type
                                         ret = new NameExpr( offsetName );
 …
+                }
+////////////////////////////////////////// Pass3 ////////////////////////////////////////////////////
+                template< typename DeclClass >
+                void Pass3::handleDecl( DeclClass * decl, Type * type ) {
+                        GuardScope( scopeTyVars );
+                        makeTyVarMap( type, scopeTyVars );
+                        ScrubTyVars::scrubAll( decl );
+                }
+                void Pass3::premutate( ObjectDecl * objectDecl ) {
+                        handleDecl( objectDecl, objectDecl->type );
+                }
+                void Pass3::premutate( FunctionDecl * functionDecl ) {
+                        handleDecl( functionDecl, functionDecl->type );
+                }
+                void Pass3::premutate( TypedefDecl * typedefDecl ) {
+                        handleDecl( typedefDecl, typedefDecl->base );
+////////////////////////////////////////// Eraser ///////////////////////////////////////////////
+                void Eraser::premutate( ObjectDecl * objectDecl ) {
+                        ScrubTyVars::scrubAll( objectDecl );
+                }
+                void Eraser::premutate( FunctionDecl * functionDecl ) {
+                        ScrubTyVars::scrubAll( functionDecl );
+                }
+                void Eraser::premutate( TypedefDecl * typedefDecl ) {
+                        ScrubTyVars::scrubAll( typedefDecl );
+                }
                 /// Strips the members from a generic aggregate
                 void stripGenericMembers(AggregateDecl * decl) {
+                static void stripGenericMembers( AggregateDecl * decl ) {
                         if ( ! decl->parameters.empty() ) decl->members.clear();
+                }
                 void Pass3::premutate( StructDecl * structDecl ) {
+                void Eraser::premutate( StructDecl * structDecl ) {
                         stripGenericMembers( structDecl );
+                }
                 void Pass3::premutate( UnionDecl * unionDecl ) {
+                void Eraser::premutate( UnionDecl * unionDecl ) {
                         stripGenericMembers( unionDecl );
+                }
-                void Pass3::premutate( TypeDecl * typeDecl ) {
-                        addToTyVarMap( typeDecl, scopeTyVars );
+                }
-                void Pass3::premutate( PointerType * pointerType ) {
-                        GuardScope( scopeTyVars );
-                        makeTyVarMap( pointerType, scopeTyVars );
+                }
-                void Pass3::premutate( FunctionType * functionType ) {
-                        GuardScope( scopeTyVars );
-                        makeTyVarMap( functionType, scopeTyVars );
+                }
         } // anonymous namespace
 …
 // compile-command: "make install" //
 // End: //

src/GenPoly/ErasableScopedMap.h

-              r34b4268
+              r24d6572
 // file "LICENCE" distributed with Cforall.
 //
 // ScopedMap.h --
+// ErasableScopedMap.h --
 //
 // Author           : Aaron B. Moss
 …
         typedef typename Scope::const_pointer const_pointer;
         // Both iterator types are complete bidirection iterators, defined below.
+        // Both iterator types are complete bidirectional iterators, see below.
         class iterator;
         class const_iterator;
 …
         std::pair< iterator, bool > insert( const Key &key, const Value &value ) { return insert( std::make_pair( key, value ) ); }
+        Value& operator[] ( const Key &key ) {
+                iterator slot = find( key );
+                if ( slot != end() ) return slot->second;
+                return insert( key, Value() ).first->second;
+        }
         /// Marks the given element as erased from this scope inward; returns 1 for erased an element, 0 otherwise
         size_type erase( const Key &key ) {
 …
+        }
+        Value& operator[] ( const Key &key ) {
+                iterator slot = find( key );
+                if ( slot != end() ) return slot->second;
+                return insert( key, Value() ).first->second;
+        bool contains( const Key & key ) const {
+                return find( key ) != cend();
+        }
 };

src/GenPoly/FindFunction.cc

-              r34b4268
+              r24d6572
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Rob Schluntz
 // Last Modified On : Fri Feb 05 12:22:20 2016
 // Update Count     : 6
+// Last Modified By : Andrew Beach
+// Last Modified On : Fri Oct  7 17:05:20 2022
+// Update Count     : 7
 //
 …
 #include <utility>                      // for pair
+#include "AST/Pass.hpp"                 // for Pass
+#include "AST/Type.hpp"
 #include "Common/PassVisitor.h"         // for PassVisitor
 #include "GenPoly/ErasableScopedMap.h"  // for ErasableScopedMap<>::iterator
 …
                 handleForall( pointerType->get_forall() );
+        }
+namespace {
+struct FindFunctionCore :
+                public ast::WithGuards,
+                public ast::WithShortCircuiting,
+                public ast::WithVisitorRef<FindFunctionCore> {
+        FindFunctionCore(
+                std::vector<ast::ptr<ast::FunctionType>> & functions,
+                const TypeVarMap & typeVars, FindFunctionPred predicate,
+                bool replaceMode );
+        void previsit( ast::FunctionType const * type );
+        ast::Type const * postvisit( ast::FunctionType const * type );
+        void previsit( ast::PointerType const * type );
+private:
+        void handleForall( const ast::FunctionType::ForallList & forall );
+        std::vector<ast::ptr<ast::FunctionType>> &functions;
+        TypeVarMap typeVars;
+        FindFunctionPred predicate;
+        bool replaceMode;
+};
+FindFunctionCore::FindFunctionCore(
+                std::vector<ast::ptr<ast::FunctionType>> & functions,
+                const TypeVarMap &typeVars, FindFunctionPred predicate,
+                bool replaceMode ) :
+        functions( functions ), typeVars( typeVars ),
+        predicate( predicate ), replaceMode( replaceMode ) {}
+void FindFunctionCore::handleForall( const ast::FunctionType::ForallList & forall ) {
+        for ( const ast::ptr<ast::TypeInstType> & td : forall ) {
+                TypeVarMap::iterator var = typeVars.find( *td );
+                if ( var != typeVars.end() ) {
+                        typeVars.erase( var->first );
+                } // if
+        } // for
+}
+void FindFunctionCore::previsit( ast::FunctionType const * type ) {
+        visit_children = false;
+        GuardScope( typeVars );
+        handleForall( type->forall );
+        //ast::accept_all( type->returns, *visitor );
+        // This might have to become ast::mutate_each with return.
+        ast::accept_each( type->returns, *visitor );
+}
+ast::Type const * FindFunctionCore::postvisit( ast::FunctionType const * type ) {
+        ast::Type const * ret = type;
+        if ( predicate( type, typeVars ) ) {
+                functions.push_back( type );
+                if ( replaceMode ) {
+                        // replace type parameters in function type with void*
+                        ret = scrubTypeVars( ast::deepCopy( type ), typeVars );
+                } // if
+        } // if
+        return ret;
+}
+void FindFunctionCore::previsit( ast::PointerType const * /*type*/ ) {
+        GuardScope( typeVars );
+        //handleForall( type->forall );
+}
+} // namespace
+void findFunction( const ast::Type * type,
+                std::vector<ast::ptr<ast::FunctionType>> & functions,
+                const TypeVarMap & typeVars, FindFunctionPred predicate ) {
+        ast::Pass<FindFunctionCore> pass( functions, typeVars, predicate, false );
+        type->accept( pass );
+        //(void)type;
+        //(void)functions;
+        //(void)typeVars;
+        //(void)predicate;
+}
+const ast::Type * findAndReplaceFunction( const ast::Type * type,
+                std::vector<ast::ptr<ast::FunctionType>> & functions,
+                const TypeVarMap & typeVars, FindFunctionPred predicate ) {
+        ast::Pass<FindFunctionCore> pass( functions, typeVars, predicate, true );
+        return type->accept( pass );
+        //(void)functions;
+        //(void)typeVars;
+        //(void)predicate;
+        //return type;
+}
 } // namespace GenPoly

src/GenPoly/FindFunction.h

-              r34b4268
+              r24d6572
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 09:23:36 2017
 // Update Count     : 2
+// Last Modified By : Andrew Beach
+// Last Modified On : Fri Oct  7 10:30:00 2022
+// Update Count     : 3
 //
 …
         /// like `findFunction`, but also replaces the function type with void ()(void)
         void findAndReplaceFunction( Type *&type, std::list< FunctionType const * > &functions, const TyVarMap &tyVars, FindFunctionPredicate predicate );
+typedef bool (*FindFunctionPred)( const ast::FunctionType *, const TypeVarMap & );
+/// Recursively walks `type`, placing all functions that match `predicate`
+/// under `typeVars` into `functions`.
+void findFunction( const ast::Type * type,
+                std::vector<ast::ptr<ast::FunctionType>> & functions,
+                const TypeVarMap & typeVars, FindFunctionPred predicate );
+/// Like findFunction, but also replaces the function type with `void ()(void)`.
+const ast::Type * findAndReplaceFunction( const ast::Type * type,
+                std::vector<ast::ptr<ast::FunctionType>> & functions,
+                const TypeVarMap & typeVars, FindFunctionPred predicate );
 } // namespace GenPoly

src/GenPoly/GenPoly.cc

-              r34b4268
+              r24d6572
 #include <vector>                       // for vector
+#include "AST/Expr.hpp"
 #include "AST/Type.hpp"
+#include "AST/TypeSubstitution.hpp"
 #include "GenPoly/ErasableScopedMap.h"  // for ErasableScopedMap<>::const_it...
 #include "ResolvExpr/typeops.h"         // for flatten
 …
                 if ( TypeInstType *typeInst = dynamic_cast< TypeInstType * >( type ) ) {
                         if ( tyVars.find( typeInst->get_name() ) != tyVars.end() ) {
+                        if ( tyVars.contains( typeInst->get_name() ) ) {
                                 return type;
+                        }
 …
                 if ( auto typeInst = dynamic_cast< const ast::TypeInstType * >( type ) ) {
                         return tyVars.find(typeInst->typeString()) != tyVars.end() ? type : nullptr;
+                        if ( tyVars.contains( typeInst->typeString() ) ) return type;
                 } else if ( auto arrayType = dynamic_cast< const ast::ArrayType * >( type ) ) {
                         return isPolyType( arrayType->base, env );
 …
         if ( auto inst = dynamic_cast< const ast::TypeInstType * >( type ) ) {
                 if ( typeVars.find( *inst ) != typeVars.end() ) return type;
+                if ( typeVars.contains( *inst ) ) return type;
         } else if ( auto array = dynamic_cast< const ast::ArrayType * >( type ) ) {
                 return isPolyType( array->base, subst );
 …
                 return (ReferenceToType*)isDynType( function->get_returnVals().front()->get_type(), forallTypes );
+        }
+const ast::BaseInstType *isDynRet( const ast::FunctionType * func ) {
+        if ( func->returns.empty() ) return nullptr;
+        TypeVarMap forallTypes = { ast::TypeData() };
+        makeTypeVarMap( func, forallTypes );
+        return isDynType( func->returns.front(), forallTypes );
+}
         bool needsAdapter( FunctionType *adaptee, const TyVarMap &tyVars ) {
 …
                 return 0;
+        }
+const ast::Type * isPolyPtr(
+                const ast::Type * type, const TypeVarMap & typeVars,
+                const ast::TypeSubstitution * typeSubs ) {
+        type = replaceTypeInst( type, typeSubs );
+        if ( auto * ptr = dynamic_cast<ast::PointerType const *>( type ) ) {
+                return isPolyType( ptr->base, typeVars, typeSubs );
+        }
+        return nullptr;
+}
         Type * hasPolyBase( Type *type, int *levels, const TypeSubstitution *env ) {
 …
                 if ( TypeInstType *typeInstType = dynamic_cast< TypeInstType * >( type ) ) {
                         if ( tyVars.find( typeInstType->get_name() ) != tyVars.end() ) {
+                        if ( tyVars.contains( typeInstType->get_name() ) ) {
                                 return true;
+                        }
 …
+                }
+                /// Flattens a list of types.
+                // There is another flattenList in Unify.
                 void flattenList( vector<ast::ptr<ast::Type>> const & src,
                                 vector<ast::ptr<ast::Type>> & out ) {
 …
+        }
+void addToTypeVarMap( const ast::TypeDecl * decl, TypeVarMap & typeVars ) {
+        typeVars.insert( ast::TypeEnvKey( decl, 0, 0 ), ast::TypeData( decl ) );
+}
 void addToTypeVarMap( const ast::TypeInstType * type, TypeVarMap & typeVars ) {
         typeVars.insert( *type, ast::TypeData( type->base ) );
+        typeVars.insert( ast::TypeEnvKey( *type ), ast::TypeData( type->base ) );
+}
 …
+}
+void makeTypeVarMap( const ast::FunctionDecl * decl, TypeVarMap & typeVars ) {
+        for ( auto & typeDecl : decl->type_params ) {
+                addToTypeVarMap( typeDecl, typeVars );
+        }
+}
         void printTyVarMap( std::ostream &os, const TyVarMap &tyVarMap ) {
                 for ( TyVarMap::const_iterator i = tyVarMap.begin(); i != tyVarMap.end(); ++i ) {

src/GenPoly/GenPoly.h

-              r34b4268
+              r24d6572
         void addToTyVarMap( TypeDecl * tyVar, TyVarMap &tyVarMap );
         void addToTypeVarMap( const ast::TypeDecl * type, TypeVarMap & typeVars );
+        void addToTypeVarMap( const ast::TypeInstType * type, TypeVarMap & typeVars );
         /// Adds the declarations in the forall list of type (and its pointed-to type if it's a pointer type) to `tyVarMap`
         void makeTyVarMap( Type *type, TyVarMap &tyVarMap );
         void makeTypeVarMap( const ast::Type * type, TypeVarMap & typeVars );
+        void makeTypeVarMap( const ast::FunctionDecl * decl, TypeVarMap & typeVars );
         /// Prints type variable map

src/GenPoly/InstantiateGeneric.cc

-              r34b4268
+              r24d6572
 #include "GenPoly.h"                   // for isPolyType, typesPolyCompatible
 #include "InitTweak/InitTweak.h"
+#include "ResolvExpr/typeops.h"
+#include "ResolvExpr/AdjustExprType.hpp"  // for adjustExprType
+#include "ResolvExpr/Unify.h"          // for typesCompatible
 #include "ScopedSet.h"                 // for ScopedSet, ScopedSet<>::iterator
 #include "ScrubTyVars.h"               // for ScrubTyVars

src/GenPoly/InstantiateGenericNew.cpp

-              r34b4268
+              r24d6572
 #include "GenPoly/GenPoly.h"           // for isPolyType, typesPolyCompatible
 #include "GenPoly/ScrubTyVars.h"       // for scrubAll
+#include "ResolvExpr/typeops.h"        // for typesCompatible
+#include "ResolvExpr/AdjustExprType.hpp"  // for adjustExprType
+#include "ResolvExpr/Unify.h"          // for typesCompatible
 namespace GenPoly {
 …
                         ResolvExpr::typesCompatible(
                                 memberExpr->result,
                                 memberExpr->member->get_type(), ast::SymbolTable() ) ) {
+                                memberExpr->member->get_type() ) ) {
                 return memberExpr;
+        }

src/GenPoly/Lvalue.cc

r34b4268	r24d6572
17	17	#include <string> // for string
18	18
	19	#include "Common/ToString.hpp" // for toCString
19	20	#include "Common/UniqueName.h"
20	21	#include "Common/PassVisitor.h"

src/GenPoly/LvalueNew.cpp

-              r34b4268
+              r24d6572
 #include "AST/Pass.hpp"
 #include "Common/SemanticError.h"      // for SemanticWarning
+#include "Common/ToString.hpp"         // for toCString
 #include "Common/UniqueName.h"         // for UniqueName
 #include "GenPoly/GenPoly.h"           // for genFunctionType
 …
                                 !ResolvExpr::typesCompatible(
                                         srcType,
+                                        strict_dynamic_cast<ast::ReferenceType const *>( dstType )->base,
+                                        ast::SymbolTable() ) ) {
+                                        strict_dynamic_cast<ast::ReferenceType const *>( dstType )->base ) ) {
                         // Must keep cast if cast-to type is different from the actual type.
                         return ast::mutate_field( expr, &ast::CastExpr::arg, ret );
 …
                 if ( !ResolvExpr::typesCompatibleIgnoreQualifiers(
                                 dstType->stripReferences(),
+                                srcType->stripReferences(),
+                                ast::SymbolTable() ) ) {
+                                srcType->stripReferences() ) ) {
                         return ast::mutate_field( expr, &ast::CastExpr::arg, ret );
+                }
 …
                                 ResolvExpr::typesCompatible(
                                         expr->result,
                                         expr->arg->result, ast::SymbolTable() ) ) {
+                                        expr->arg->result ) ) {
                         PRINT(
                                 std::cerr << "types are compatible, removing cast: " << expr << '\n';
 …
                 ast::OpenVarSet openVars;
                 ResolvExpr::unify( ret->arg2->result, ret->arg3->result, newEnv,
+                        needAssertions, haveAssertions, openVars,
+                        ast::SymbolTable(), common );
+                        needAssertions, haveAssertions, openVars, common );
                 ret->result = common ? common : ast::deepCopy( ret->arg2->result );
                 return ret;

src/GenPoly/ScopedSet.h

-              r34b4268
+              r24d6572
 namespace GenPoly {
+        /// A set where the items are placed into nested scopes;
+        /// inserted items are placed into the innermost scope, lookup looks from the innermost scope outward
+        template<typename Value>
+        class ScopedSet {
+                typedef std::set< Value > Scope;
+                typedef std::vector< Scope > ScopeList;
+                ScopeList scopes; ///< scoped list of sets
+        public:
+                typedef typename Scope::key_type key_type;
+                typedef typename Scope::value_type value_type;
+                typedef typename ScopeList::size_type size_type;
+                typedef typename ScopeList::difference_type difference_type;
+                typedef typename Scope::reference reference;
+                typedef typename Scope::const_reference const_reference;
+                typedef typename Scope::pointer pointer;
+                typedef typename Scope::const_pointer const_pointer;
+                class iterator : public std::iterator< std::bidirectional_iterator_tag,
+                                                       value_type > {
+                friend class ScopedSet;
+                friend class const_iterator;
+                        typedef typename std::set< Value >::iterator wrapped_iterator;
+                        typedef typename std::vector< std::set< Value > > scope_list;
+                        typedef typename scope_list::size_type size_type;
+                        /// Checks if this iterator points to a valid item
+                        bool is_valid() const {
+                                return it != (*scopes)[i].end();
+                        }
+                        /// Increments on invalid
+                        iterator& next_valid() {
+                                if ( ! is_valid() ) { ++(*this); }
+                                return *this;
+                        }
+                        /// Decrements on invalid
+                        iterator& prev_valid() {
+                                if ( ! is_valid() ) { --(*this); }
+                                return *this;
+                        }
+                        iterator(scope_list const &_scopes, const wrapped_iterator &_it, size_type _i)
+                                : scopes(&_scopes), it(_it), i(_i) {}
+                public:
+                        iterator(const iterator &that) : scopes(that.scopes), it(that.it), i(that.i) {}
+                        iterator& operator= (const iterator &that) {
+                                scopes = that.scopes; i = that.i; it = that.it;
+                                return *this;
+                        }
+                        reference operator* () { return *it; }
+                        pointer operator-> () { return it.operator->(); }
+                        iterator& operator++ () {
+                                if ( it == (*scopes)[i].end() ) {
+                                        if ( i == 0 ) return *this;
+                                        --i;
+                                        it = (*scopes)[i].begin();
+                                } else {
+                                        ++it;
+                                }
+                                return next_valid();
+                        }
+                        iterator operator++ (int) { iterator tmp = *this; ++(*this); return tmp; }
+                        iterator& operator-- () {
+                                // may fail if this is the begin iterator; allowed by STL spec
+                                if ( it == (*scopes)[i].begin() ) {
+                                        ++i;
+                                        it = (*scopes)[i].end();
+                                }
+                                --it;
+                                return prev_valid();
+                        }
+                        iterator operator-- (int) { iterator tmp = *this; --(*this); return tmp; }
+                        bool operator== (const iterator &that) {
+                                return scopes == that.scopes && i == that.i && it == that.it;
+                        }
+                        bool operator!= (const iterator &that) { return !( *this == that ); }
+                        size_type get_level() const { return i; }
+                private:
+                        scope_list const *scopes;
+                        wrapped_iterator it;
+                        size_type i;
+                };
+                class const_iterator : public std::iterator< std::bidirectional_iterator_tag,
+                                                             value_type > {
+                friend class ScopedSet;
+                        typedef typename std::set< Value >::iterator wrapped_iterator;
+                        typedef typename std::set< Value >::const_iterator wrapped_const_iterator;
+                        typedef typename std::vector< std::set< Value > > scope_list;
+                        typedef typename scope_list::size_type size_type;
+                        /// Checks if this iterator points to a valid item
+                        bool is_valid() const {
+                                return it != (*scopes)[i].end();
+                        }
+                        /// Increments on invalid
+                        const_iterator& next_valid() {
+                                if ( ! is_valid() ) { ++(*this); }
+                                return *this;
+                        }
+                        /// Decrements on invalid
+                        const_iterator& prev_valid() {
+                                if ( ! is_valid() ) { --(*this); }
+                                return *this;
+                        }
+                        const_iterator(scope_list const &_scopes, const wrapped_const_iterator &_it, size_type _i)
+                                : scopes(&_scopes), it(_it), i(_i) {}
+                public:
+                        const_iterator(const iterator &that) : scopes(that.scopes), it(that.it), i(that.i) {}
+                        const_iterator(const const_iterator &that) : scopes(that.scopes), it(that.it), i(that.i) {}
+                        const_iterator& operator= (const iterator &that) {
+                                scopes = that.scopes; i = that.i; it = that.it;
+                                return *this;
+                        }
+                        const_iterator& operator= (const const_iterator &that) {
+                                scopes = that.scopes; i = that.i; it = that.it;
+                                return *this;
+                        }
+                        const_reference operator* () { return *it; }
+                        const_pointer operator-> () { return it.operator->(); }
+                        const_iterator& operator++ () {
+                                if ( it == (*scopes)[i].end() ) {
+                                        if ( i == 0 ) return *this;
+                                        --i;
+                                        it = (*scopes)[i].begin();
+                                } else {
+                                        ++it;
+                                }
+                                return next_valid();
+                        }
+                        const_iterator operator++ (int) { const_iterator tmp = *this; ++(*this); return tmp; }
+                        const_iterator& operator-- () {
+                                // may fail if this is the begin iterator; allowed by STL spec
+                                if ( it == (*scopes)[i].begin() ) {
+                                        ++i;
+                                        it = (*scopes)[i].end();
+                                }
+                                --it;
+                                return prev_valid();
+                        }
+                        const_iterator operator-- (int) { const_iterator tmp = *this; --(*this); return tmp; }
+                        bool operator== (const const_iterator &that) {
+                                return scopes == that.scopes && i == that.i && it == that.it;
+                        }
+                        bool operator!= (const const_iterator &that) { return !( *this == that ); }
+                        size_type get_level() const { return i; }
+                private:
+                        scope_list const *scopes;
+                        wrapped_const_iterator it;
+                        size_type i;
+                };
+                /// Starts a new scope
+                void beginScope() {
+                        Scope scope;
+                        scopes.push_back(scope);
+                }
+                /// Ends a scope; invalidates any iterators pointing to elements of that scope
+                void endScope() {
+                        scopes.pop_back();
+                }
+                /// Default constructor initializes with one scope
+                ScopedSet() { beginScope(); }
+                iterator begin() { return iterator(scopes, scopes.back().begin(), scopes.size()-1).next_valid(); }
+                const_iterator begin() const { return const_iterator(scopes, scopes.back().begin(), scopes.size()-1).next_valid(); }
+                const_iterator cbegin() const { return const_iterator(scopes, scopes.back().begin(), scopes.size()-1).next_valid(); }
+                iterator end() { return iterator(scopes, scopes[0].end(), 0); }
+                const_iterator end() const { return const_iterator(scopes, scopes[0].end(), 0); }
+                const_iterator cend() const { return const_iterator(scopes, scopes[0].end(), 0); }
+                /// Gets the index of the current scope (counted from 1)
+                size_type currentScope() const { return scopes.size(); }
+                /// Finds the given key in the outermost scope it occurs; returns end() for none such
+                iterator find( const Value &key ) {
+                        for ( size_type i = scopes.size() - 1; ; --i ) {
+                                typename Scope::iterator val = scopes[i].find( key );
+                                if ( val != scopes[i].end() ) return iterator( scopes, val, i );
+                                if ( i == 0 ) break;
+                        }
+                        return end();
+                }
+                const_iterator find( const Value &key ) const {
+                        return const_iterator( const_cast< ScopedSet< Value >* >(this)->find( key ) );
+                }
+                /// Finds the given key in the outermost scope inside the given scope where it occurs
+                iterator findNext( const_iterator &it, const Value &key ) {
+                        if ( it.i == 0 ) return end();
+/// A set where the items are placed into nested scopes;
+/// inserted items are placed into the innermost scope, lookup looks from the innermost scope outward
+template<typename Value>
+class ScopedSet {
+        typedef std::set< Value > Scope;
+        typedef std::vector< Scope > ScopeList;
+        /// Scoped list of sets.
+        ScopeList scopes;
+public:
+        typedef typename Scope::key_type key_type;
+        typedef typename Scope::value_type value_type;
+        typedef typename ScopeList::size_type size_type;
+        typedef typename ScopeList::difference_type difference_type;
+        typedef typename Scope::reference reference;
+        typedef typename Scope::const_reference const_reference;
+        typedef typename Scope::pointer pointer;
+        typedef typename Scope::const_pointer const_pointer;
+        // Both iterator types are complete bidirectional iterators, see below.
+        class iterator;
+        class const_iterator;
+        /// Starts a new scope
+        void beginScope() {
+                Scope scope;
+                scopes.push_back(scope);
+        }
+        /// Ends a scope; invalidates any iterators pointing to elements of that scope
+        void endScope() {
+                scopes.pop_back();
+        }
+        /// Default constructor initializes with one scope
+        ScopedSet() { beginScope(); }
+        iterator begin() { return iterator(scopes, scopes.back().begin(), scopes.size()-1).next_valid(); }
+        const_iterator begin() const { return const_iterator(scopes, scopes.back().begin(), scopes.size()-1).next_valid(); }
+        const_iterator cbegin() const { return const_iterator(scopes, scopes.back().begin(), scopes.size()-1).next_valid(); }
+        iterator end() { return iterator(scopes, scopes[0].end(), 0); }
+        const_iterator end() const { return const_iterator(scopes, scopes[0].end(), 0); }
+        const_iterator cend() const { return const_iterator(scopes, scopes[0].end(), 0); }
+        /// Gets the index of the current scope (counted from 1)
+        size_type currentScope() const { return scopes.size(); }
+        /// Finds the given key in the outermost scope it occurs; returns end() for none such
+        iterator find( const Value &key ) {
+                for ( size_type i = scopes.size() - 1; ; --i ) {
+                        typename Scope::iterator val = scopes[i].find( key );
+                        if ( val != scopes[i].end() ) return iterator( scopes, val, i );
+                        if ( i == 0 ) break;
+                }
+                return end();
+        }
+        const_iterator find( const Value &key ) const {
+                return const_iterator( const_cast< ScopedSet< Value >* >(this)->find( key ) );
+        }
+        /// Finds the given key in the outermost scope inside the given scope where it occurs
+        iterator findNext( const_iterator &it, const Value &key ) {
+                if ( it.i == 0 ) return end();
                         for ( size_type i = it.i - 1; ; --i ) {
+                                typename Scope::iterator val = scopes[i].find( key );
+                                if ( val != scopes[i].end() ) return iterator( scopes, val, i );
+                                if ( i == 0 ) break;
+                        }
+                        return end();
+                }
+                const_iterator findNext( const_iterator &it, const Value &key ) const {
+                        return const_iterator( const_cast< ScopedSet< Value >* >(this)->findNext( it, key ) );
+                }
+                /// Inserts the given value into the outermost scope
+                std::pair< iterator, bool > insert( const value_type &value ) {
+                        std::pair< typename Scope::iterator, bool > res = scopes.back().insert( value );
+                        return std::make_pair( iterator(scopes, res.first, scopes.size()-1), res.second );
+                }
+        };
+                        typename Scope::iterator val = scopes[i].find( key );
+                        if ( val != scopes[i].end() ) return iterator( scopes, val, i );
+                        if ( i == 0 ) break;
+                }
+                return end();
+        }
+        const_iterator findNext( const_iterator &it, const Value &key ) const {
+                return const_iterator( const_cast< ScopedSet< Value >* >(this)->findNext( it, key ) );
+        }
+        /// Inserts the given value into the outermost scope
+        std::pair< iterator, bool > insert( const value_type &value ) {
+                std::pair< typename Scope::iterator, bool > res = scopes.back().insert( value );
+                return std::make_pair( iterator(scopes, res.first, scopes.size()-1), res.second );
+        }
+        bool contains( const Value & key ) const {
+                return find( key ) != cend();
+        }
+};
+template<typename Value>
+class ScopedSet<Value>::iterator :
+                public std::iterator< std::bidirectional_iterator_tag, value_type > {
+        friend class ScopedSet;
+        friend class const_iterator;
+        typedef typename std::set< Value >::iterator wrapped_iterator;
+        typedef typename std::vector< std::set< Value > > scope_list;
+        typedef typename scope_list::size_type size_type;
+        /// Checks if this iterator points to a valid item
+        bool is_valid() const {
+                return it != (*scopes)[i].end();
+        }
+        /// Increments on invalid
+        iterator& next_valid() {
+                if ( ! is_valid() ) { ++(*this); }
+                return *this;
+        }
+        /// Decrements on invalid
+        iterator& prev_valid() {
+                if ( ! is_valid() ) { --(*this); }
+                return *this;
+        }
+        iterator(scope_list const &_scopes, const wrapped_iterator &_it, size_type _i)
+                : scopes(&_scopes), it(_it), i(_i) {}
+public:
+        iterator(const iterator &that) : scopes(that.scopes), it(that.it), i(that.i) {}
+        iterator& operator= (const iterator &that) {
+                scopes = that.scopes; i = that.i; it = that.it;
+                return *this;
+        }
+        reference operator* () { return *it; }
+        pointer operator-> () { return it.operator->(); }
+        iterator& operator++ () {
+                if ( it == (*scopes)[i].end() ) {
+                        if ( i == 0 ) return *this;
+                        --i;
+                        it = (*scopes)[i].begin();
+                } else {
+                        ++it;
+                }
+                return next_valid();
+        }
+        iterator operator++ (int) { iterator tmp = *this; ++(*this); return tmp; }
+        iterator& operator-- () {
+                // may fail if this is the begin iterator; allowed by STL spec
+                if ( it == (*scopes)[i].begin() ) {
+                        ++i;
+                        it = (*scopes)[i].end();
+                }
+                --it;
+                return prev_valid();
+        }
+        iterator operator-- (int) { iterator tmp = *this; --(*this); return tmp; }
+        bool operator== (const iterator &that) {
+                return scopes == that.scopes && i == that.i && it == that.it;
+        }
+        bool operator!= (const iterator &that) { return !( *this == that ); }
+        size_type get_level() const { return i; }
+private:
+        scope_list const *scopes;
+        wrapped_iterator it;
+        size_type i;
+};
+template<typename Value>
+class ScopedSet<Value>::const_iterator :
+                public std::iterator< std::bidirectional_iterator_tag, value_type > {
+        friend class ScopedSet;
+        typedef typename std::set< Value >::iterator wrapped_iterator;
+        typedef typename std::set< Value >::const_iterator wrapped_const_iterator;
+        typedef typename std::vector< std::set< Value > > scope_list;
+        typedef typename scope_list::size_type size_type;
+        /// Checks if this iterator points to a valid item
+        bool is_valid() const {
+                return it != (*scopes)[i].end();
+        }
+        /// Increments on invalid
+        const_iterator& next_valid() {
+                if ( ! is_valid() ) { ++(*this); }
+                return *this;
+        }
+        /// Decrements on invalid
+        const_iterator& prev_valid() {
+                if ( ! is_valid() ) { --(*this); }
+                return *this;
+        }
+        const_iterator(scope_list const &_scopes, const wrapped_const_iterator &_it, size_type _i)
+                : scopes(&_scopes), it(_it), i(_i) {}
+public:
+        const_iterator(const iterator &that) : scopes(that.scopes), it(that.it), i(that.i) {}
+        const_iterator(const const_iterator &that) : scopes(that.scopes), it(that.it), i(that.i) {}
+        const_iterator& operator= (const iterator &that) {
+                scopes = that.scopes; i = that.i; it = that.it;
+                return *this;
+        }
+        const_iterator& operator= (const const_iterator &that) {
+                scopes = that.scopes; i = that.i; it = that.it;
+                return *this;
+        }
+        const_reference operator* () { return *it; }
+        const_pointer operator-> () { return it.operator->(); }
+        const_iterator& operator++ () {
+                if ( it == (*scopes)[i].end() ) {
+                        if ( i == 0 ) return *this;
+                        --i;
+                        it = (*scopes)[i].begin();
+                } else {
+                        ++it;
+                }
+                return next_valid();
+        }
+        const_iterator operator++ (int) { const_iterator tmp = *this; ++(*this); return tmp; }
+        const_iterator& operator-- () {
+                // may fail if this is the begin iterator; allowed by STL spec
+                if ( it == (*scopes)[i].begin() ) {
+                        ++i;
+                        it = (*scopes)[i].end();
+                }
+                --it;
+                return prev_valid();
+        }
+        const_iterator operator-- (int) { const_iterator tmp = *this; --(*this); return tmp; }
+        bool operator== (const const_iterator &that) {
+                return scopes == that.scopes && i == that.i && it == that.it;
+        }
+        bool operator!= (const const_iterator &that) { return !( *this == that ); }
+        size_type get_level() const { return i; }
+private:
+        scope_list const *scopes;
+        wrapped_const_iterator it;
+        size_type i;
+};
 } // namespace GenPoly

src/GenPoly/ScrubTyVars.cc

-              r34b4268
+              r24d6572
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Andrew Beach
 // Last Modified On : Fri Oct  7 15:42:00 2022
 // Update Count     : 5
+// Last Modified On : Wed Dec  7 17:01:00 2022
+// Update Count     : 6
 //
 …
 namespace {
-enum class ScrubMode {
-        FromMap,
-        DynamicFromMap,
-        All,
-};
 struct ScrubTypeVars :
         public ast::WithGuards,
 …
 ast::Type const * ScrubTypeVars::postvisit( ast::TypeInstType const * type ) {
+        ast::TypeDecl::Kind kind;
         // This implies that mode == ScrubMode::All.
         if ( !typeVars ) {
+                if ( ast::TypeDecl::Ftype == type->kind ) {
+                        return new ast::PointerType(
+                                new ast::FunctionType( ast::FixedArgs ) );
+                } else {
+                        return new ast::PointerType(
+                                new ast::VoidType( type->qualifiers ) );
+                }
+        }
+        auto typeVar = typeVars->find( *type );
+        if ( typeVar == typeVars->end() ) {
+                return type;
+        }
+        switch ( typeVar->second.kind ) {
+        case ::TypeDecl::Dtype:
+        case ::TypeDecl::Ttype:
+                kind = type->kind;
+        } else {
+                // Otherwise, only scrub the type var if it is in map.
+                auto typeVar = typeVars->find( *type );
+                if ( typeVar == typeVars->end() ) {
+                        return type;
+                }
+                kind = typeVar->second.kind;
+        }
+        switch ( kind ) {
+        case ast::TypeDecl::Dtype:
+        case ast::TypeDecl::Ttype:
                 return new ast::PointerType(
                         new ast::VoidType( type->qualifiers ) );
         case ::TypeDecl::Ftype:
+        case ast::TypeDecl::Ftype:
                 return new ast::PointerType(
                         new ast::FunctionType( ast::VariableArgs ) );
         default:
+                assertf( false,
+                        "Unhandled type variable kind: %d", typeVar->second.kind );
+                assertf( false, "Unhandled type variable kind: %d", kind );
                 throw; // Just in case the assert is removed, stop here.
+        }
 …
+}
+} // namespace
 const ast::Node * scrubTypeVarsBase(
+                const ast::Node * target,
+                ScrubMode mode, const TypeVarMap * typeVars ) {
+                const ast::Node * node, const TypeVarMap * typeVars, ScrubMode mode ) {
         if ( ScrubMode::All == mode ) {
                 assert( nullptr == typeVars );
 …
+        }
         ast::Pass<ScrubTypeVars> visitor( mode, typeVars );
+        return target->accept( visitor );
+}
+} // namespace
+template<>
+ast::Node const * scrubTypeVars<ast::Node>(
+        const ast::Node * target, const TypeVarMap & typeVars ) {
+        return scrubTypeVarsBase( target, ScrubMode::FromMap, &typeVars );
+}
+template<>
+ast::Node const * scrubTypeVarsDynamic<ast::Node>(
+        ast::Node const * target, const TypeVarMap & typeVars ) {
+        return scrubTypeVarsBase( target, ScrubMode::DynamicFromMap, &typeVars );
+}
+template<>
+ast::Node const * scrubAllTypeVars<ast::Node>( const ast::Node * target ) {
+        return scrubTypeVarsBase( target, ScrubMode::All, nullptr );
+        return node->accept( visitor );
+}

src/GenPoly/ScrubTyVars.h

-              r34b4268
+              r24d6572
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Andrew Beach
 // Last Modified On : Fri Oct  7 15:51:00 2022
 // Update Count     : 4
+// Last Modified On : Wed Dec  7 16:57:00 2022
+// Update Count     : 5
 //
 …
+        }
+// ScrubMode and scrubTypeVarsBase are internal.
+enum class ScrubMode { FromMap, DynamicFromMap, All };
+const ast::Node * scrubTypeVarsBase(
+        const ast::Node * target, const TypeVarMap * typeVars, ScrubMode mode );
 /// For all polymorphic types with type variables in `typeVars`,
 /// replaces generic types, dtypes, and ftypes with the appropriate void type,
 …
                 node_t const * target, const TypeVarMap & typeVars ) {
         return strict_dynamic_cast<node_t const *>(
                         scrubTypeVars<ast::Node>( target, typeVars ) );
+                        scrubTypeVarsBase( target, &typeVars, ScrubMode::FromMap ) );
+}
 …
 /// and sizeof/alignof expressions with the proper variable.
 template<typename node_t>
 ast::Node const * scrubTypeVarsDynamic(
+node_t const * scrubTypeVarsDynamic(
                 node_t const * target, const TypeVarMap & typeVars ) {
         return strict_dynamic_cast<node_t const *>(
                         scrubTypeVarsDynamic<ast::Node>( target, typeVars ) );
+                        scrubTypeVarsBase( target, &typeVars, ScrubMode::DynamicFromMap ) );
+}
 …
 node_t const * scrubAllTypeVars( node_t const * target ) {
         return strict_dynamic_cast<node_t const *>(
                         scrubAllTypeVars<ast::Node>( target ) );
+                        scrubTypeVarsBase( target, nullptr, ScrubMode::All ) );
+}
-// We specialize for Node as a base case.
-template<>
-ast::Node const * scrubTypeVars<ast::Node>(
-                const ast::Node * target, const TypeVarMap & typeVars );
-template<>
-ast::Node const * scrubTypeVarsDynamic<ast::Node>(
-                ast::Node const * target, const TypeVarMap & typeVars );
-template<>
-ast::Node const * scrubAllTypeVars<ast::Node>( const ast::Node * target );
 } // namespace GenPoly

src/GenPoly/SpecializeNew.cpp

r34b4268	r24d6572
16	16	#include "Specialize.h"
17	17
	18	#include "AST/Copy.hpp" // for deepCopy
18	19	#include "AST/Inspect.hpp" // for isIntrinsicCallExpr
19	20	#include "AST/Pass.hpp" // for Pass

src/InitTweak/FixInit.cc

-              r34b4268
+              r24d6572
 #include "Common/PassVisitor.h"        // for PassVisitor, WithStmtsToAdd
 #include "Common/SemanticError.h"      // for SemanticError
+#include "Common/ToString.hpp"         // for toCString
 #include "Common/UniqueName.h"         // for UniqueName
-#include "Common/utility.h"            // for CodeLocation, ValueGuard, toSt...
 #include "FixGlobalInit.h"             // for fixGlobalInit
 #include "GenInit.h"                   // for genCtorDtor
 …
 #include "InitTweak.h"                 // for getFunctionName, getCallArg
 #include "ResolvExpr/Resolver.h"       // for findVoidExpression
 #include "ResolvExpr/typeops.h"        // for typesCompatible
+#include "ResolvExpr/Unify.h"          // for typesCompatible
 #include "SymTab/Autogen.h"            // for genImplicitCall
 #include "SymTab/Indexer.h"            // for Indexer
 …
+                }
-                template< typename Visitor, typename... Params >
-                void error( Visitor & v, CodeLocation loc, const Params &... params ) {
-                        SemanticErrorException err( loc, toString( params... ) );
-                        v.errors.append( err );
+                }
                 template< typename... Params >
                 void GenStructMemberCalls::emit( CodeLocation loc, const Params &... params ) {
+                        // toggle warnings vs. errors here.
+                        // warn( params... );
+                        error( *this, loc, params... );
+                        SemanticErrorException err( loc, toString( params... ) );
+                        errors.append( err );
+                }

src/InitTweak/FixInitNew.cpp

-              r34b4268
+              r24d6572
 #include <utility>                     // for pair
+#include "AST/DeclReplacer.hpp"
+#include "AST/Expr.hpp"
 #include "AST/Inspect.hpp"             // for getFunction, getPointerBase, g...
+#include "AST/Node.hpp"
+#include "AST/Pass.hpp"
+#include "AST/Print.hpp"
+#include "AST/SymbolTable.hpp"
+#include "AST/Type.hpp"
 #include "CodeGen/GenType.h"           // for genPrettyType
 #include "CodeGen/OperatorTable.h"
-#include "Common/CodeLocationTools.hpp"
 #include "Common/PassVisitor.h"        // for PassVisitor, WithStmtsToAdd
 #include "Common/SemanticError.h"      // for SemanticError
+#include "Common/ToString.hpp"         // for toCString
 #include "Common/UniqueName.h"         // for UniqueName
-#include "Common/utility.h"            // for CodeLocation, ValueGuard, toSt...
 #include "FixGlobalInit.h"             // for fixGlobalInit
 #include "GenInit.h"                   // for genCtorDtor
 #include "GenPoly/GenPoly.h"           // for getFunctionType
 #include "ResolvExpr/Resolver.h"       // for findVoidExpression
 #include "ResolvExpr/typeops.h"        // for typesCompatible
+#include "ResolvExpr/Unify.h"          // for typesCompatible
 #include "SymTab/Autogen.h"            // for genImplicitCall
+#include "SymTab/GenImplicitCall.hpp"  // for genImplicitCall
 #include "SymTab/Indexer.h"            // for Indexer
 #include "SymTab/Mangler.h"            // for Mangler
 …
 #include "Validate/FindSpecialDecls.h" // for dtorStmt, dtorStructDestroy
-#include "AST/Expr.hpp"
-#include "AST/Node.hpp"
-#include "AST/Pass.hpp"
-#include "AST/Print.hpp"
-#include "AST/SymbolTable.hpp"
-#include "AST/Type.hpp"
-#include "AST/DeclReplacer.hpp"
 extern bool ctordtorp; // print all debug
 extern bool ctorp; // print ctor debug
 …
 namespace InitTweak {
 namespace {
+        // Shallow copy the pointer list for return.
+        std::vector<ast::ptr<ast::TypeDecl>> getGenericParams( const ast::Type * t ) {
+                if ( auto inst = dynamic_cast<const ast::StructInstType *>( t ) ) {
+                        return inst->base->params;
+                }
+                if ( auto inst = dynamic_cast<const ast::UnionInstType *>( t ) ) {
+                        return inst->base->params;
+                }
+                return {};
+        }
+        /// Given type T, generate type of default ctor/dtor, i.e. function type void (*) (T &).
+        ast::FunctionDecl * genDefaultFunc(
+                        const CodeLocation loc,
+                        const std::string fname,
+                        const ast::Type * paramType,
+                        bool maybePolymorphic = true) {
+                std::vector<ast::ptr<ast::TypeDecl>> typeParams;
+                if ( maybePolymorphic ) typeParams = getGenericParams( paramType );
+                auto dstParam = new ast::ObjectDecl( loc,
+                        "_dst",
+                        new ast::ReferenceType( paramType ),
+                        nullptr,
+                        {},
+                        ast::Linkage::Cforall
+                );
+                return new ast::FunctionDecl( loc,
+                        fname,
+                        std::move(typeParams),
+                        {dstParam},
+                        {},
+                        new ast::CompoundStmt(loc),
+                        {},
+                        ast::Linkage::Cforall
+                );
+        }
         struct SelfAssignChecker {
                 void previsit( const ast::ApplicationExpr * appExpr );
 …
         private:
                 /// hack to implement WithTypeSubstitution while conforming to mutation safety.
                 ast::TypeSubstitution * env;
                 bool                    envModified;
+                ast::TypeSubstitution * env         = nullptr;
+                bool                    envModified = false;
         };
 …
                 void previsit( const ast::FunctionDecl * ) { visit_children = false; }
           protected:
+        protected:
                 ObjectSet curVars;
         };
 …
                 SemanticErrorException errors;
           private:
+        private:
                 template< typename... Params >
                 void emit( CodeLocation, const Params &... params );
 …
                 static UniqueName dtorNamer( "__cleanup_dtor" );
                 std::string name = dtorNamer.newName();
                 ast::FunctionDecl * dtorFunc = SymTab::genDefaultFunc( loc, name, objDecl->type->stripReferences(), false );
+                ast::FunctionDecl * dtorFunc = genDefaultFunc( loc, name, objDecl->type->stripReferences(), false );
                 stmtsToAdd.push_back( new ast::DeclStmt(loc, dtorFunc ) );
 …
+        {
                 static UniqueName tempNamer("_tmp_cp");
-                assert( env );
                 const CodeLocation loc = impCpCtorExpr->location;
                 // CP_CTOR_PRINT( std::cerr << "Type Substitution: " << *env << std::endl; )
 …
                 // xxx - this originally mutates arg->result in place. is it correct?
+                assert( env );
                 result = env->applyFree( result.get() ).node;
                 auto mutResult = result.get_and_mutate();
 …
         void InsertDtors::previsit( const ast::BranchStmt * stmt ) {
                 switch( stmt->kind ) {
                   case ast::BranchStmt::Continue:
                   case ast::BranchStmt::Break:
+                case ast::BranchStmt::Continue:
+                case ast::BranchStmt::Break:
                         // could optimize the break/continue case, because the S_L-S_G check is unnecessary (this set should
                         // always be empty), but it serves as a small sanity check.
                   case ast::BranchStmt::Goto:
+                case ast::BranchStmt::Goto:
                         handleGoto( stmt );
                         break;
                   default:
+                default:
                         assert( false );
                 } // switch
 …
+        }
-        template< typename Visitor, typename... Params >
-        void error( Visitor & v, CodeLocation loc, const Params &... params ) {
-                SemanticErrorException err( loc, toString( params... ) );
-                v.errors.append( err );
+        }
         template< typename... Params >
         void GenStructMemberCalls::emit( CodeLocation loc, const Params &... params ) {
+                // toggle warnings vs. errors here.
+                // warn( params... );
+                error( *this, loc, params... );
+                SemanticErrorException err( loc, toString( params... ) );
+                errors.append( err );
+        }
 …
                 // xxx - functions returning ast::ptr seems wrong...
                 auto res = ResolvExpr::findVoidExpression( untypedExpr, { symtab, transUnit().global } );
+                // Fix CodeLocation (at least until resolver is fixed).
+                auto fix = localFillCodeLocations( untypedExpr->location, res.release() );
+                return strict_dynamic_cast<const ast::Expr *>( fix );
+                return res.release();
+        }

src/InitTweak/GenInit.cc

-              r34b4268
+              r24d6572
 #include "Common/PassVisitor.h"        // for PassVisitor, WithGuards, WithShort...
 #include "Common/SemanticError.h"      // for SemanticError
+#include "Common/ToString.hpp"         // for toCString
 #include "Common/UniqueName.h"         // for UniqueName
 #include "Common/utility.h"            // for ValueGuard, maybeClone
 …
 #include "ResolvExpr/Resolver.h"
 #include "SymTab/Autogen.h"            // for genImplicitCall
+#include "SymTab/GenImplicitCall.hpp"  // for genImplicitCall
 #include "SymTab/Mangler.h"            // for Mangler
 #include "SynTree/LinkageSpec.h"       // for isOverridable, C

src/InitTweak/InitTweak.cc

-              r34b4268
+              r24d6572
 #include "GenPoly/GenPoly.h"       // for getFunctionType
 #include "InitTweak.h"
 #include "ResolvExpr/typeops.h"    // for typesCompatibleIgnoreQualifiers
+#include "ResolvExpr/Unify.h"      // for typesCompatibleIgnoreQualifiers
 #include "SymTab/Autogen.h"
 #include "SymTab/Indexer.h"        // for Indexer
 …
         const ast::Type * t2 = ftype->params.back();
         return ResolvExpr::typesCompatibleIgnoreQualifiers( t1, t2, ast::SymbolTable() );
+        return ResolvExpr::typesCompatibleIgnoreQualifiers( t1, t2 );
+}

src/MakeLibCfaNew.cpp

r34b4268	r24d6572
16	16	#include "MakeLibCfa.h"
17	17
	18	#include "AST/Copy.hpp"
18	19	#include "AST/Fwd.hpp"
19	20	#include "AST/Pass.hpp"

src/Parser/DeclarationNode.cc

-              r34b4268
+              r24d6572
 // Author           : Rodolfo G. Esteves
 // Created On       : Sat May 16 12:34:05 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Mon Aug  8 17:07:00 2022
 // Update Count     : 1185
+// Last Modified By : Andrew Beach
+// Last Modified On : Thr Apr 20 11:46:00 2023
+// Update Count     : 1393
 //
+#include "DeclarationNode.h"
 #include <cassert>                 // for assert, assertf, strict_dynamic_cast
 …
 #include <string>                  // for string, operator+, allocator, char...
+#include "AST/Attribute.hpp"       // for Attribute
+#include "AST/Copy.hpp"            // for shallowCopy
+#include "AST/Decl.hpp"            // for Decl
+#include "AST/Expr.hpp"            // for Expr
+#include "AST/Print.hpp"           // for print
+#include "AST/Stmt.hpp"            // for AsmStmt, DirectiveStmt
+#include "AST/StorageClasses.hpp"  // for Storage::Class
+#include "AST/Type.hpp"            // for Type
+#include "Common/CodeLocation.h"   // for CodeLocation
+#include "Common/Iterate.hpp"      // for reverseIterate
 #include "Common/SemanticError.h"  // for SemanticError
 #include "Common/UniqueName.h"     // for UniqueName
+#include "Common/utility.h"        // for maybeClone, maybeBuild, CodeLocation
+#include "Parser/ParseNode.h"      // for DeclarationNode, ExpressionNode
+#include "SynTree/LinkageSpec.h"   // for Spec, linkageName, Cforall
+#include "SynTree/Attribute.h"     // for Attribute
+#include "SynTree/Declaration.h"   // for TypeDecl, ObjectDecl, InlineMemberDecl, Declaration
+#include "SynTree/Expression.h"    // for Expression, ConstantExpr
+#include "SynTree/Statement.h"     // for AsmStmt
+#include "SynTree/Type.h"          // for Type, Type::StorageClasses, Type::...
+#include "Common/utility.h"        // for maybeClone
+#include "Parser/ExpressionNode.h" // for ExpressionNode
+#include "Parser/InitializerNode.h"// for InitializerNode
+#include "Parser/StatementNode.h"  // for StatementNode
 #include "TypeData.h"              // for TypeData, TypeData::Aggregate_t
 #include "TypedefTable.h"          // for TypedefTable
 …
 // 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::signednessNames[] = { "signed", "unsigned", "NoSignednessNames" };
+const char * DeclarationNode::lengthNames[] = { "short", "long", "long long", "NoLengthNames" };
+const char * DeclarationNode::builtinTypeNames[] = { "__builtin_va_list", "__auto_type", "zero_t", "one_t", "NoBuiltinTypeNames" };
+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::signednessNames[] = {
+        "signed", "unsigned", "NoSignednessNames"
+};
+const char * DeclarationNode::lengthNames[] = {
+        "short", "long", "long long", "NoLengthNames"
+};
+const char * DeclarationNode::builtinTypeNames[] = {
+        "__builtin_va_list", "__auto_type", "zero_t", "one_t", "NoBuiltinTypeNames"
+};
 UniqueName DeclarationNode::anonymous( "__anonymous" );
 extern LinkageSpec::Spec linkage;                                               // defined in parser.yy
+extern ast::Linkage::Spec linkage;                                              // defined in parser.yy
 DeclarationNode::DeclarationNode() :
 …
 //      variable.name = nullptr;
         variable.tyClass = TypeDecl::NUMBER_OF_KINDS;
+        variable.tyClass = ast::TypeDecl::NUMBER_OF_KINDS;
         variable.assertions = nullptr;
         variable.initializer = nullptr;
-//      attr.name = nullptr;
-        attr.expr = nullptr;
-        attr.type = nullptr;
         assert.condition = nullptr;
         assert.message = nullptr;
 …
 DeclarationNode::~DeclarationNode() {
-//      delete attr.name;
-        delete attr.expr;
-        delete attr.type;
 //      delete variable.name;
         delete variable.assertions;
         delete variable.initializer;
 //      delete type;
+//      delete type;
         delete bitfieldWidth;
 …
         newnode->hasEllipsis = hasEllipsis;
         newnode->linkage = linkage;
         newnode->asmName = maybeClone( asmName );
         cloneAll( attributes, newnode->attributes );
+        newnode->asmName = maybeCopy( asmName );
+        newnode->attributes = attributes;
         newnode->initializer = maybeClone( initializer );
         newnode->extension = extension;
 …
         newnode->variable.initializer = maybeClone( variable.initializer );
-//      newnode->attr.name = attr.name ? new string( *attr.name ) : nullptr;
-        newnode->attr.expr = maybeClone( attr.expr );
-        newnode->attr.type = maybeClone( attr.type );
         newnode->assert.condition = maybeClone( assert.condition );
         newnode->assert.message = maybeClone( assert.message );
+        newnode->assert.message = maybeCopy( assert.message );
         return newnode;
 } // DeclarationNode::clone
 …
         } // if
         if ( linkage != LinkageSpec::Cforall ) {
                 os << LinkageSpec::name( linkage ) << " ";
         } // if
         storageClasses.print( os );
         funcSpecs.print( os );
+        if ( linkage != ast::Linkage::Cforall ) {
+                os << ast::Linkage::name( linkage ) << " ";
+        } // if
+        ast::print( os, storageClasses );
+        ast::print( os, funcSpecs );
         if ( type ) {
 …
         } // if
+        for ( Attribute * attr: reverseIterate( attributes ) ) {
+                os << string( indent + 2, ' ' ) << "attr " << attr->name.c_str();
+        } // for
+        if ( ! attributes.empty() ) {
+                os << string( indent + 2, ' ' ) << "with attributes " << endl;
+                for ( ast::ptr<ast::Attribute> const & attr : reverseIterate( attributes ) ) {
+                        os << string( indent + 4, ' ' ) << attr->name.c_str() << endl;
+                } // for
+        } // if
         os << endl;
 …
+}
 DeclarationNode * DeclarationNode::newStorageClass( Type::StorageClasses sc ) {
+DeclarationNode * DeclarationNode::newStorageClass( ast::Storage::Classes sc ) {
         DeclarationNode * newnode = new DeclarationNode;
         newnode->storageClasses = sc;
 …
 } // DeclarationNode::newStorageClass
 DeclarationNode * DeclarationNode::newFuncSpecifier( Type::FuncSpecifiers fs ) {
+DeclarationNode * DeclarationNode::newFuncSpecifier( ast::Function::Specs fs ) {
         DeclarationNode * newnode = new DeclarationNode;
         newnode->funcSpecs = fs;
 …
 } // DeclarationNode::newFuncSpecifier
 DeclarationNode * DeclarationNode::newTypeQualifier( Type::Qualifiers tq ) {
+DeclarationNode * DeclarationNode::newTypeQualifier( ast::CV::Qualifiers tq ) {
         DeclarationNode * newnode = new DeclarationNode;
         newnode->type = new TypeData();
 …
+}
 DeclarationNode * DeclarationNode::newAggregate( AggregateDecl::Aggregate kind, const string * name, ExpressionNode * actuals, DeclarationNode * fields, bool body ) {
+DeclarationNode * DeclarationNode::newAggregate( ast::AggregateDecl::Aggregate kind, const string * name, ExpressionNode * actuals, DeclarationNode * fields, bool body ) {
         DeclarationNode * newnode = new DeclarationNode;
         newnode->type = new TypeData( TypeData::Aggregate );
         newnode->type->aggregate.kind = kind;
+        newnode->type->aggregate.name = name == nullptr ? new string( DeclarationNode::anonymous.newName() ) : name;
+        newnode->type->aggregate.anon = name == nullptr;
+        newnode->type->aggregate.name = newnode->type->aggregate.anon ? new string( DeclarationNode::anonymous.newName() ) : name;
         newnode->type->aggregate.actuals = actuals;
         newnode->type->aggregate.fields = fields;
 …
         newnode->type->aggregate.tagged = false;
         newnode->type->aggregate.parent = nullptr;
-        newnode->type->aggregate.anon = name == nullptr;
         return newnode;
 } // DeclarationNode::newAggregate
 …
         DeclarationNode * newnode = new DeclarationNode;
         newnode->type = new TypeData( TypeData::Enum );
+        newnode->type->enumeration.name = name == nullptr ? new string( DeclarationNode::anonymous.newName() ) : name;
+        newnode->type->enumeration.anon = name == nullptr;
+        newnode->type->enumeration.name = newnode->type->enumeration.anon ? new string( DeclarationNode::anonymous.newName() ) : name;
         newnode->type->enumeration.constants = constants;
         newnode->type->enumeration.body = body;
-        newnode->type->enumeration.anon = name == nullptr;
         newnode->type->enumeration.typed = typed;
         newnode->type->enumeration.hiding = hiding;
         if ( base && base->type)  {
+        if ( base && base->type )  {
                 newnode->type->base = base->type;
         } // if
 …
         return newnode;
 } // DeclarationNode::newEnum
 DeclarationNode * DeclarationNode::newName( const string * name ) {
 …
 } // DeclarationNode::newFromTypeGen
 DeclarationNode * DeclarationNode::newTypeParam( TypeDecl::Kind tc, const string * name ) {
+DeclarationNode * DeclarationNode::newTypeParam( ast::TypeDecl::Kind tc, const string * name ) {
         DeclarationNode * newnode = newName( name );
         newnode->type = nullptr;
 …
         newnode->type = new TypeData( TypeData::Aggregate );
         newnode->type->aggregate.name = name;
         newnode->type->aggregate.kind = AggregateDecl::Trait;
+        newnode->type->aggregate.kind = ast::AggregateDecl::Trait;
         newnode->type->aggregate.params = params;
         newnode->type->aggregate.fields = asserts;
 …
         newnode->type = new TypeData( TypeData::AggregateInst );
         newnode->type->aggInst.aggregate = new TypeData( TypeData::Aggregate );
         newnode->type->aggInst.aggregate->aggregate.kind = AggregateDecl::Trait;
+        newnode->type->aggInst.aggregate->aggregate.kind = ast::AggregateDecl::Trait;
         newnode->type->aggInst.aggregate->aggregate.name = name;
         newnode->type->aggInst.params = params;
 …
         newnode->type->array.dimension = size;
         newnode->type->array.isStatic = isStatic;
         if ( newnode->type->array.dimension == nullptr || newnode->type->array.dimension->isExpressionType<ConstantExpr * >() ) {
+        if ( newnode->type->array.dimension == nullptr || newnode->type->array.dimension->isExpressionType<ast::ConstantExpr *>() ) {
                 newnode->type->array.isVarLen = false;
         } else {
 …
         DeclarationNode * newnode = new DeclarationNode;
         newnode->type = nullptr;
         std::list< Expression * > exprs;
+        std::vector<ast::ptr<ast::Expr>> exprs;
         buildList( expr, exprs );
+        newnode->attributes.push_back( new Attribute( *name, exprs ) );
+        newnode->attributes.push_back(
+                new ast::Attribute( *name, std::move( exprs ) ) );
         delete name;
         return newnode;
 …
+}
 DeclarationNode * DeclarationNode::newStaticAssert( ExpressionNode * condition, Expression * message ) {
+DeclarationNode * DeclarationNode::newStaticAssert( ExpressionNode * condition, ast::Expr * message ) {
         DeclarationNode * newnode = new DeclarationNode;
         newnode->assert.condition = condition;
 …
+}
+void appendError( string & dst, const string & src ) {
+static void appendError( string & dst, const string & src ) {
         if ( src.empty() ) return;
         if ( dst.empty() ) { dst = src; return; }
 …
 void DeclarationNode::checkQualifiers( const TypeData * src, const TypeData * dst ) {
+        const Type::Qualifiers qsrc = src->qualifiers, qdst = dst->qualifiers; // optimization
+        if ( (qsrc & qdst).any() ) {                                            // duplicates ?
+                for ( unsigned int i = 0; i < Type::NumTypeQualifier; i += 1 ) { // find duplicates
+                        if ( qsrc[i] && qdst[i] ) {
+                                appendError( error, string( "duplicate " ) + Type::QualifiersNames[i] );
+                        } // if
+                } // for
+        const ast::CV::Qualifiers qsrc = src->qualifiers, qdst = dst->qualifiers; // optimization
+        const ast::CV::Qualifiers duplicates = qsrc & qdst;
+        if ( duplicates.any() ) {
+                std::stringstream str;
+                str << "duplicate ";
+                ast::print( str, duplicates );
+                str << "qualifier(s)";
+                appendError( error, str.str() );
         } // for
 } // DeclarationNode::checkQualifiers
 void DeclarationNode::checkSpecifiers( DeclarationNode * src ) {
+        if ( (funcSpecs & src->funcSpecs).any() ) {                     // duplicates ?
+                for ( unsigned int i = 0; i < Type::NumFuncSpecifier; i += 1 ) { // find duplicates
+                        if ( funcSpecs[i] && src->funcSpecs[i] ) {
+                                appendError( error, string( "duplicate " ) + Type::FuncSpecifiersNames[i] );
+                        } // if
+                } // for
+        } // if
+        if ( storageClasses.any() && src->storageClasses.any() ) { // any reason to check ?
+                if ( (storageClasses & src->storageClasses ).any() ) { // duplicates ?
+                        for ( unsigned int i = 0; i < Type::NumStorageClass; i += 1 ) { // find duplicates
+                                if ( storageClasses[i] && src->storageClasses[i] ) {
+                                        appendError( error, string( "duplicate " ) + Type::StorageClassesNames[i] );
+                                } // if
+                        } // for
+                        // src is the new item being added and has a single bit
+                } else if ( ! src->storageClasses.is_threadlocal_any() ) { // conflict ?
+                        appendError( error, string( "conflicting " ) + Type::StorageClassesNames[storageClasses.ffs()] +
+                                                 " & " + Type::StorageClassesNames[src->storageClasses.ffs()] );
+                        src->storageClasses.reset();                            // FIX to preserve invariant of one basic storage specifier
+                } // if
+        ast::Function::Specs fsDups = funcSpecs & src->funcSpecs;
+        if ( fsDups.any() ) {
+                std::stringstream str;
+                str << "duplicate ";
+                ast::print( str, fsDups );
+                str << "function specifier(s)";
+                appendError( error, str.str() );
+        } // if
+        // Skip if everything is unset.
+        if ( storageClasses.any() && src->storageClasses.any() ) {
+                ast::Storage::Classes dups = storageClasses & src->storageClasses;
+                // Check for duplicates.
+                if ( dups.any() ) {
+                        std::stringstream str;
+                        str << "duplicate ";
+                        ast::print( str, dups );
+                        str << "storage class(es)";
+                        appendError( error, str.str() );
+                // Check for conflicts.
+                } else if ( !src->storageClasses.is_threadlocal_any() ) {
+                        std::stringstream str;
+                        str << "conflicting ";
+                        ast::print( str, ast::Storage::Classes( 1 << storageClasses.ffs() ) );
+                        str << "& ";
+                        ast::print( str, ast::Storage::Classes( 1 << src->storageClasses.ffs() ) );
+                        str << "storage classes";
+                        appendError( error, str.str() );
+                        // FIX to preserve invariant of one basic storage specifier
+                        src->storageClasses.reset();
+                }
         } // if
 …
         storageClasses |= q->storageClasses;
+        for ( Attribute * attr: reverseIterate( q->attributes ) ) {
+                attributes.push_front( attr->clone() );
+        } // for
+        std::vector<ast::ptr<ast::Attribute>> tmp;
+        tmp.reserve( q->attributes.size() );
+        for ( auto const & attr : q->attributes ) {
+                tmp.emplace_back( ast::shallowCopy( attr.get() ) );
+        }
+        spliceBegin( attributes, tmp );
         return this;
 } // DeclarationNode::copySpecifiers
 …
         checkQualifiers( type, q->type );
         if ( (builtin == Zero || builtin == One) && q->type->qualifiers.val != 0 && error.length() == 0 ) {
                 SemanticWarning( yylloc, Warning::BadQualifiersZeroOne, Type::QualifiersNames[ilog2( q->type->qualifiers.val )], builtinTypeNames[builtin] );
+        if ( (builtin == Zero || builtin == One) && q->type->qualifiers.any() && error.length() == 0 ) {
+                SemanticWarning( yylloc, Warning::BadQualifiersZeroOne, builtinTypeNames[builtin] );
         } // if
         addQualifiersToType( q->type, type );
 …
         } else {
                 switch ( dst->kind ) {
                   case TypeData::Unknown:
+                case TypeData::Unknown:
                         src->qualifiers |= dst->qualifiers;
                         dst = src;
                         src = nullptr;
                         break;
                   case TypeData::Basic:
+                case TypeData::Basic:
                         dst->qualifiers |= src->qualifiers;
                         if ( src->kind != TypeData::Unknown ) {
 …
                         } // if
                         break;
                   default:
+                default:
                         switch ( src->kind ) {
                           case TypeData::Aggregate:
                           case TypeData::Enum:
+                        case TypeData::Aggregate:
+                        case TypeData::Enum:
                                 dst->base = new TypeData( TypeData::AggregateInst );
                                 dst->base->aggInst.aggregate = src;
 …
                                 src = nullptr;
                                 break;
                           default:
+                        default:
                                 if ( dst->forall ) {
                                         dst->forall->appendList( src->forall );
 …
 DeclarationNode * DeclarationNode::addAssertions( DeclarationNode * assertions ) {
         if ( variable.tyClass != TypeDecl::NUMBER_OF_KINDS ) {
                 if ( variable.assertions ) {
                         variable.assertions->appendList( assertions );
                 } else {
                         variable.assertions = assertions;
                 } // if
                 return this;
+        if ( variable.tyClass != ast::TypeDecl::NUMBER_OF_KINDS ) {
+                if ( variable.assertions ) {
+                        variable.assertions->appendList( assertions );
+                } else {
+                        variable.assertions = assertions;
+                } // if
+                return this;
         } // if
         assert( type );
         switch ( type->kind ) {
           case TypeData::Symbolic:
+        case TypeData::Symbolic:
                 if ( type->symbolic.assertions ) {
                         type->symbolic.assertions->appendList( assertions );
 …
                 } // if
                 break;
           default:
+        default:
                 assert( false );
         } // switch
 …
 DeclarationNode * DeclarationNode::copyAttribute( DeclarationNode * a ) {
         if ( a ) {
+                for ( Attribute *attr: reverseIterate( a->attributes ) ) {
+                        attributes.push_front( attr );
+                } // for
+                spliceBegin( attributes, a->attributes );
                 a->attributes.clear();
         } // if
 …
                 if ( type ) {
                         switch ( type->kind ) {
                           case TypeData::Aggregate:
                           case TypeData::Enum:
+                        case TypeData::Aggregate:
+                        case TypeData::Enum:
                                 p->type->base = new TypeData( TypeData::AggregateInst );
                                 p->type->base->aggInst.aggregate = type;
 …
                                 break;
                           default:
+                        default:
                                 p->type->base = type;
                         } // switch
 …
 DeclarationNode * DeclarationNode::addNewArray( DeclarationNode * a ) {
   if ( ! a ) return this;
+        if ( ! a ) return this;
         assert( a->type->kind == TypeData::Array );
         TypeData * lastArray = findLast( a->type );
         if ( type ) {
                 switch ( type->kind ) {
                   case TypeData::Aggregate:
                   case TypeData::Enum:
+                case TypeData::Aggregate:
+                case TypeData::Enum:
                         lastArray->base = new TypeData( TypeData::AggregateInst );
                         lastArray->base->aggInst.aggregate = type;
 …
                         lastArray->base->qualifiers |= type->qualifiers;
                         break;
                   default:
+                default:
                         lastArray->base = type;
                 } // switch
 …
 DeclarationNode * DeclarationNode::addTypeInitializer( DeclarationNode * init ) {
         assertf( variable.tyClass != TypeDecl::NUMBER_OF_KINDS, "Called addTypeInitializer on something that isn't a type variable." );
+        assertf( variable.tyClass != ast::TypeDecl::NUMBER_OF_KINDS, "Called addTypeInitializer on something that isn't a type variable." );
         variable.initializer = init;
         return this;
 …
+}
+void buildList( const DeclarationNode * firstNode, std::list< Declaration * > & outputList ) {
+// If a typedef wraps an anonymous declaration, name the inner declaration
+// so it has a consistent name across translation units.
+static void nameTypedefedDecl(
+                DeclarationNode * innerDecl,
+                const DeclarationNode * outerDecl ) {
+        TypeData * outer = outerDecl->type;
+        assert( outer );
+        // First make sure this is a typedef:
+        if ( outer->kind != TypeData::Symbolic || !outer->symbolic.isTypedef ) {
+                return;
+        }
+        TypeData * inner = innerDecl->type;
+        assert( inner );
+        // Always clear any CVs associated with the aggregate:
+        inner->qualifiers.reset();
+        // Handle anonymous aggregates: typedef struct { int i; } foo
+        if ( inner->kind == TypeData::Aggregate && inner->aggregate.anon ) {
+                delete inner->aggregate.name;
+                inner->aggregate.name = new string( "__anonymous_" + *outerDecl->name );
+                inner->aggregate.anon = false;
+                assert( outer->base );
+                delete outer->base->aggInst.aggregate->aggregate.name;
+                outer->base->aggInst.aggregate->aggregate.name = new string( "__anonymous_" + *outerDecl->name );
+                outer->base->aggInst.aggregate->aggregate.anon = false;
+                outer->base->aggInst.aggregate->qualifiers.reset();
+        // Handle anonymous enumeration: typedef enum { A, B, C } foo
+        } else if ( inner->kind == TypeData::Enum && inner->enumeration.anon ) {
+                delete inner->enumeration.name;
+                inner->enumeration.name = new string( "__anonymous_" + *outerDecl->name );
+                inner->enumeration.anon = false;
+                assert( outer->base );
+                delete outer->base->aggInst.aggregate->enumeration.name;
+                outer->base->aggInst.aggregate->enumeration.name = new string( "__anonymous_" + *outerDecl->name );
+                outer->base->aggInst.aggregate->enumeration.anon = false;
+                // No qualifiers.reset() here.
+        }
+}
+// This code handles a special issue with the attribute transparent_union.
+//
+//    typedef union U { int i; } typedef_name __attribute__(( aligned(16) )) __attribute__(( transparent_union ))
+//
+// Here the attribute aligned goes with the typedef_name, so variables declared of this type are
+// aligned.  However, the attribute transparent_union must be moved from the typedef_name to
+// alias union U.  Currently, this is the only know attribute that must be moved from typedef to
+// alias.
+static void moveUnionAttribute( ast::Decl * decl, ast::UnionDecl * unionDecl ) {
+        if ( auto typedefDecl = dynamic_cast<ast::TypedefDecl *>( decl ) ) {
+                // Is the typedef alias a union aggregate?
+                if ( nullptr == unionDecl ) return;
+                // If typedef is an alias for a union, then its alias type was hoisted above and remembered.
+                if ( auto unionInstType = typedefDecl->base.as<ast::UnionInstType>() ) {
+                        auto instType = ast::mutate( unionInstType );
+                        // Remove all transparent_union attributes from typedef and move to alias union.
+                        for ( auto attr = instType->attributes.begin() ; attr != instType->attributes.end() ; ) {
+                                assert( *attr );
+                                if ( (*attr)->name == "transparent_union" || (*attr)->name == "__transparent_union__" ) {
+                                        unionDecl->attributes.emplace_back( attr->release() );
+                                        attr = instType->attributes.erase( attr );
+                                } else {
+                                        attr++;
+                                }
+                        }
+                        typedefDecl->base = instType;
+                }
+        }
+}
+// Get the non-anonymous name of the instance type of the declaration,
+// if one exists.
+static const std::string * getInstTypeOfName( ast::Decl * decl ) {
+        if ( auto dwt = dynamic_cast<ast::DeclWithType *>( decl ) ) {
+                if ( auto aggr = dynamic_cast<ast::BaseInstType const *>( dwt->get_type() ) ) {
+                        if ( aggr->name.find("anonymous") == std::string::npos ) {
+                                return &aggr->name;
+                        }
+                }
+        }
+        return nullptr;
+}
+void buildList( DeclarationNode * firstNode,
+                std::vector<ast::ptr<ast::Decl>> & outputList ) {
         SemanticErrorException errors;
         std::back_insert_iterator< std::list< Declaration * > > out( outputList );
         for ( const DeclarationNode * cur = firstNode; cur; cur = dynamic_cast< DeclarationNode * >( cur->get_next() ) ) {
+        std::back_insert_iterator<std::vector<ast::ptr<ast::Decl>>> out( outputList );
+        for ( const DeclarationNode * cur = firstNode ; cur ; cur = strict_next( cur ) ) {
                 try {
+                        bool extracted = false;
+                        bool anon = false;
+                        bool extracted_named = false;
+                        ast::UnionDecl * unionDecl = nullptr;
                         if ( DeclarationNode * extr = cur->extractAggregate() ) {
+                                // handle the case where a structure declaration is contained within an object or type declaration
+                                Declaration * decl = extr->build();
+                                if ( decl ) {
+                                        // hoist the structure declaration
+                                        decl->location = cur->location;
+                                        * out++ = decl;
+                                assert( cur->type );
+                                nameTypedefedDecl( extr, cur );
+                                if ( ast::Decl * decl = extr->build() ) {
+                                        // Remember the declaration if it is a union aggregate ?
+                                        unionDecl = dynamic_cast<ast::UnionDecl *>( decl );
+                                        *out++ = decl;
                                         // need to remember the cases where a declaration contains an anonymous aggregate definition
-                                        extracted = true;
                                         assert( extr->type );
                                         if ( extr->type->kind == TypeData::Aggregate ) {
+                                                anon = extr->type->aggregate.anon;
+                                                // typedef struct { int A } B is the only case?
+                                                extracted_named = !extr->type->aggregate.anon;
                                         } else if ( extr->type->kind == TypeData::Enum ) {
+                                                // xxx - is it useful to have an implicit anonymous enum member?
+                                                anon = extr->type->enumeration.anon;
+                                                // typedef enum { A } B is the only case?
+                                                extracted_named = !extr->type->enumeration.anon;
+                                        } else {
+                                                extracted_named = true;
+                                        }
                                 } // if
 …
                         } // if
+                        Declaration * decl = cur->build();
+                        if ( decl ) {
+                                // don't include anonymous declaration for named aggregates, but do include them for anonymous aggregates, e.g.:
+                                // struct S {
+                                //   struct T { int x; }; // no anonymous member
+                                //   struct { int y; };   // anonymous member
+                                //   struct T;            // anonymous member
+                                // };
+                                if ( ! (extracted && decl->name == "" && ! anon && ! cur->get_inLine()) ) {
+                                        if ( decl->name == "" ) {
+                                                if ( DeclarationWithType * dwt = dynamic_cast<DeclarationWithType *>( decl ) ) {
+                                                        if ( ReferenceToType * aggr = dynamic_cast<ReferenceToType *>( dwt->get_type() ) ) {
+                                                                if ( aggr->name.find("anonymous") == std::string::npos ) {
+                                                                        if ( ! cur->get_inLine() ) {
+                                                                                // temporary: warn about anonymous member declarations of named types, since
+                                                                                // this conflicts with the syntax for the forward declaration of an anonymous type
+                                                                                SemanticWarning( cur->location, Warning::AggrForwardDecl, aggr->name.c_str() );
+                                                                        } // if
+                                                                } // if
+                                                        } // if
+                                                } // if
+                                        } // if
+                                        decl->location = cur->location;
+                                        *out++ = decl;
+                        if ( ast::Decl * decl = cur->build() ) {
+                                moveUnionAttribute( decl, unionDecl );
+                                if ( "" == decl->name && !cur->get_inLine() ) {
+                                        // Don't include anonymous declaration for named aggregates,
+                                        // but do include them for anonymous aggregates, e.g.:
+                                        // struct S {
+                                        //   struct T { int x; }; // no anonymous member
+                                        //   struct { int y; };   // anonymous member
+                                        //   struct T;            // anonymous member
+                                        // };
+                                        if ( extracted_named ) {
+                                                continue;
+                                        }
+                                        if ( auto name = getInstTypeOfName( decl ) ) {
+                                                // Temporary: warn about anonymous member declarations of named types, since
+                                                // this conflicts with the syntax for the forward declaration of an anonymous type.
+                                                SemanticWarning( cur->location, Warning::AggrForwardDecl, name->c_str() );
+                                        }
                                 } // if
+                                *out++ = decl;
                         } // if
                 } catch( SemanticErrorException & e ) {
+                } catch ( SemanticErrorException & e ) {
                         errors.append( e );
                 } // try
 …
 // currently only builds assertions, function parameters, and return values
 void buildList( const DeclarationNode * firstNode, std::list< DeclarationWithType * > & outputList ) {
+void buildList( DeclarationNode * firstNode, std::vector<ast::ptr<ast::DeclWithType>> & outputList ) {
         SemanticErrorException errors;
         std::back_insert_iterator< std::list< DeclarationWithType * > > out( outputList );
         for ( const DeclarationNode * cur = firstNode; cur; cur = dynamic_cast< DeclarationNode * >( cur->get_next() ) ) {
+        std::back_insert_iterator<std::vector<ast::ptr<ast::DeclWithType>>> out( outputList );
+        for ( const DeclarationNode * cur = firstNode; cur; cur = strict_next( cur ) ) {
                 try {
                         Declaration * decl = cur->build();
                         assert( decl );
                         if ( DeclarationWithType * dwt = dynamic_cast< DeclarationWithType * >( decl ) ) {
+                        ast::Decl * decl = cur->build();
+                        assertf( decl, "buildList: build for ast::DeclWithType." );
+                        if ( ast::DeclWithType * dwt = dynamic_cast<ast::DeclWithType *>( decl ) ) {
                                 dwt->location = cur->location;
                                 *out++ = dwt;
                         } else if ( StructDecl * agg = dynamic_cast< StructDecl * >( decl ) ) {
+                        } else if ( ast::StructDecl * agg = dynamic_cast<ast::StructDecl *>( decl ) ) {
                                 // e.g., int foo(struct S) {}
                                 StructInstType * inst = new StructInstType( Type::Qualifiers(), agg->name );
                                 auto obj = new ObjectDecl( "", Type::StorageClasses(), linkage, nullptr, inst, nullptr );
                                 obj->location = cur->location;
+                                auto inst = new ast::StructInstType( agg->name );
+                                auto obj = new ast::ObjectDecl( cur->location, "", inst );
+                                obj->linkage = linkage;
                                 *out++ = obj;
                                 delete agg;
                         } else if ( UnionDecl * agg = dynamic_cast< UnionDecl * >( decl ) ) {
+                        } else if ( ast::UnionDecl * agg = dynamic_cast<ast::UnionDecl *>( decl ) ) {
                                 // e.g., int foo(union U) {}
+                                UnionInstType * inst = new UnionInstType( Type::Qualifiers(), agg->name );
+                                auto obj = new ObjectDecl( "", Type::StorageClasses(), linkage, nullptr, inst, nullptr );
+                                obj->location = cur->location;
+                                auto inst = new ast::UnionInstType( agg->name );
+                                auto obj = new ast::ObjectDecl( cur->location,
+                                        "", inst, nullptr, ast::Storage::Classes(),
+                                        linkage );
                                 *out++ = obj;
                         } else if ( EnumDecl * agg = dynamic_cast< EnumDecl * >( decl ) ) {
+                        } else if ( ast::EnumDecl * agg = dynamic_cast<ast::EnumDecl *>( decl ) ) {
                                 // e.g., int foo(enum E) {}
+                                EnumInstType * inst = new EnumInstType( Type::Qualifiers(), agg->name );
+                                auto obj = new ObjectDecl( "", Type::StorageClasses(), linkage, nullptr, inst, nullptr );
+                                obj->location = cur->location;
+                                auto inst = new ast::EnumInstType( agg->name );
+                                auto obj = new ast::ObjectDecl( cur->location,
+                                        "",
+                                        inst,
+                                        nullptr,
+                                        ast::Storage::Classes(),
+                                        linkage
+                                );
                                 *out++ = obj;
+                        } else {
+                                assertf( false, "buildList: Could not convert to ast::DeclWithType." );
                         } // if
                 } catch( SemanticErrorException & e ) {
+                } catch ( SemanticErrorException & e ) {
                         errors.append( e );
                 } // try
 …
 } // buildList
+void buildTypeList( const DeclarationNode * firstNode, std::list< Type * > & outputList ) {
+void buildTypeList( const DeclarationNode * firstNode,
+                std::vector<ast::ptr<ast::Type>> & outputList ) {
         SemanticErrorException errors;
+        std::back_insert_iterator< std::list< Type * > > out( outputList );
+        const DeclarationNode * cur = firstNode;
+        while ( cur ) {
+        std::back_insert_iterator<std::vector<ast::ptr<ast::Type>>> out( outputList );
+        for ( const DeclarationNode * cur = firstNode ; cur ; cur = strict_next( cur ) ) {
                 try {
                         * out++ = cur->buildType();
                 } catch( SemanticErrorException & e ) {
+                } catch ( SemanticErrorException & e ) {
                         errors.append( e );
                 } // try
+                cur = dynamic_cast< DeclarationNode * >( cur->get_next() );
+        } // while
+        } // for
         if ( ! errors.isEmpty() ) {
 …
 } // buildTypeList
 Declaration * DeclarationNode::build() const {
+ast::Decl * DeclarationNode::build() const {
         if ( ! error.empty() ) SemanticError( this, error + " in declaration of " );
         if ( asmStmt ) {
+                return new AsmDecl( strict_dynamic_cast<AsmStmt *>( asmStmt->build() ) );
+                auto stmt = strict_dynamic_cast<ast::AsmStmt *>( asmStmt->build() );
+                return new ast::AsmDecl( stmt->location, stmt );
         } // if
         if ( directiveStmt ) {
+                return new DirectiveDecl( strict_dynamic_cast<DirectiveStmt *>( directiveStmt->build() ) );
+        } // if
+        if ( variable.tyClass != TypeDecl::NUMBER_OF_KINDS ) {
+                auto stmt = strict_dynamic_cast<ast::DirectiveStmt *>( directiveStmt->build() );
+                return new ast::DirectiveDecl( stmt->location, stmt );
+        } // if
+        if ( variable.tyClass != ast::TypeDecl::NUMBER_OF_KINDS ) {
                 // otype is internally converted to dtype + otype parameters
                 static const TypeDecl::Kind kindMap[] = { TypeDecl::Dtype, TypeDecl::Dtype, TypeDecl::Dtype, TypeDecl::Ftype, TypeDecl::Ttype, TypeDecl::Dimension };
                 static_assert( sizeof(kindMap) / sizeof(kindMap[0]) == TypeDecl::NUMBER_OF_KINDS, "DeclarationNode::build: kindMap is out of sync." );
+                static const ast::TypeDecl::Kind kindMap[] = { ast::TypeDecl::Dtype, ast::TypeDecl::Dtype, ast::TypeDecl::Dtype, ast::TypeDecl::Ftype, ast::TypeDecl::Ttype, ast::TypeDecl::Dimension };
+                static_assert( sizeof(kindMap) / sizeof(kindMap[0]) == ast::TypeDecl::NUMBER_OF_KINDS, "DeclarationNode::build: kindMap is out of sync." );
                 assertf( variable.tyClass < sizeof(kindMap)/sizeof(kindMap[0]), "Variable's tyClass is out of bounds." );
+                TypeDecl * ret = new TypeDecl( *name, Type::StorageClasses(), nullptr, kindMap[ variable.tyClass ], variable.tyClass == TypeDecl::Otype || variable.tyClass == TypeDecl::DStype, variable.initializer ? variable.initializer->buildType() : nullptr );
+                buildList( variable.assertions, ret->get_assertions() );
+                ast::TypeDecl * ret = new ast::TypeDecl( location,
+                        *name,
+                        ast::Storage::Classes(),
+                        (ast::Type *)nullptr,
+                        kindMap[ variable.tyClass ],
+                        variable.tyClass == ast::TypeDecl::Otype || variable.tyClass == ast::TypeDecl::DStype,
+                        variable.initializer ? variable.initializer->buildType() : nullptr
+                );
+                buildList( variable.assertions, ret->assertions );
                 return ret;
         } // if
 …
                 } // if
                 bool isDelete = initializer && initializer->get_isDelete();
+                Declaration * decl = buildDecl( type, name ? *name : string( "" ), storageClasses, maybeBuild< Expression >( bitfieldWidth ), funcSpecs, linkage, asmName, isDelete ? nullptr : maybeBuild< Initializer >(initializer), attributes )->set_extension( extension );
+                ast::Decl * decl = buildDecl(
+                        type,
+                        name ? *name : string( "" ),
+                        storageClasses,
+                        maybeBuild( bitfieldWidth ),
+                        funcSpecs,
+                        linkage,
+                        asmName,
+                        isDelete ? nullptr : maybeBuild( initializer ),
+                        copy( attributes )
+                )->set_extension( extension );
                 if ( isDelete ) {
                         DeclarationWithType * dwt = strict_dynamic_cast<DeclarationWithType *>( decl );
+                        auto dwt = strict_dynamic_cast<ast::DeclWithType *>( decl );
                         dwt->isDeleted = true;
+                }
 …
         if ( assert.condition ) {
+                return new StaticAssertDecl( maybeBuild< Expression >( assert.condition ), strict_dynamic_cast< ConstantExpr * >( maybeClone( assert.message ) ) );
+                auto cond = maybeBuild( assert.condition );
+                auto msg = strict_dynamic_cast<ast::ConstantExpr *>( maybeCopy( assert.message ) );
+                return new ast::StaticAssertDecl( location, cond, msg );
+        }
 …
         } // if
         if ( enumInLine ) {
+                return new InlineMemberDecl( *name, storageClasses, linkage, nullptr );
+                return new ast::InlineMemberDecl( location,
+                        *name, (ast::Type*)nullptr, storageClasses, linkage );
         } // if
         assertf( name, "ObjectDecl must a have name\n" );
+        return (new ObjectDecl( *name, storageClasses, linkage, maybeBuild< Expression >( bitfieldWidth ), nullptr, maybeBuild< Initializer >( initializer ) ))->set_asmName( asmName )->set_extension( extension );
+}
+Type * DeclarationNode::buildType() const {
+        auto ret = new ast::ObjectDecl( location,
+                *name,
+                (ast::Type*)nullptr,
+                maybeBuild( initializer ),
+                storageClasses,
+                linkage,
+                maybeBuild( bitfieldWidth )
+        );
+        ret->asmName = asmName;
+        ret->extension = extension;
+        return ret;
+}
+ast::Type * DeclarationNode::buildType() const {
         assert( type );
-        if ( attr.expr ) {
-                return new AttrType( buildQualifiers( type ), *name, attr.expr->build(), attributes );
-        } else if ( attr.type ) {
-                return new AttrType( buildQualifiers( type ), *name, attr.type->buildType(), attributes );
-        } // if
         switch ( type->kind ) {
+          case TypeData::Enum:
+          case TypeData::Aggregate: {
+                  ReferenceToType * ret = buildComAggInst( type, attributes, linkage );
+                  buildList( type->aggregate.actuals, ret->get_parameters() );
+                  return ret;
+          }
+          case TypeData::Symbolic: {
+                  TypeInstType * ret = new TypeInstType( buildQualifiers( type ), *type->symbolic.name, false, attributes );
+                  buildList( type->symbolic.actuals, ret->get_parameters() );
+                  return ret;
+          }
+          default:
+                Type * simpletypes = typebuild( type );
+                simpletypes->get_attributes() = attributes;             // copy because member is const
+        case TypeData::Enum:
+        case TypeData::Aggregate: {
+                ast::BaseInstType * ret =
+                        buildComAggInst( type, copy( attributes ), linkage );
+                buildList( type->aggregate.actuals, ret->params );
+                return ret;
+        }
+        case TypeData::Symbolic: {
+                ast::TypeInstType * ret = new ast::TypeInstType(
+                        *type->symbolic.name,
+                        // This is just a default, the true value is not known yet.
+                        ast::TypeDecl::Dtype,
+                        buildQualifiers( type ),
+                        copy( attributes ) );
+                buildList( type->symbolic.actuals, ret->params );
+                return ret;
+        }
+        default:
+                ast::Type * simpletypes = typebuild( type );
+                // copy because member is const
+                simpletypes->attributes = attributes;
                 return simpletypes;
         } // switch

src/Parser/ExpressionNode.cc

-              r34b4268
+              r24d6572
 // Author           : Peter A. Buhr
 // Created On       : Sat May 16 13:17:07 2015
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Sat Aug  7 09:18:56 2021
+// Update Count     : 1077
+//
+// Last Modified By : Andrew Beach
+// Last Modified On : Tue Apr  4 11:07:00 2023
+// Update Count     : 1083
+//
+#include "ExpressionNode.h"
 #include <cassert>                 // for assert
 …
 #include <string>                  // for string, operator+, operator==
+#include "AST/Expr.hpp"            // for NameExpr
+#include "AST/Type.hpp"            // for BaseType, SueInstType
 #include "Common/SemanticError.h"  // for SemanticError
 #include "Common/utility.h"        // for maybeMoveBuild, maybeBuild, CodeLo...
+#include "ParseNode.h"             // for ExpressionNode, maybeMoveBuildType
+#include "SynTree/Constant.h"      // for Constant
+#include "SynTree/Declaration.h"   // for EnumDecl, StructDecl, UnionDecl
+#include "SynTree/Expression.h"    // for Expression, ConstantExpr, NameExpr
+#include "SynTree/Statement.h"     // for CompoundStmt, Statement
+#include "SynTree/Type.h"          // for BasicType, Type, Type::Qualifiers
+#include "DeclarationNode.h"       // for DeclarationNode
+#include "InitializerNode.h"       // for InitializerNode
 #include "parserutility.h"         // for notZeroExpr
-class Initializer;
 using namespace std;
 …
 // because the CONT rule is NOT triggered if the pattern is empty. Hence, constants are reparsed here to determine their
 // type.
-extern const Type::Qualifiers noQualifiers;                             // no qualifiers on constants
 // static inline bool checkH( char c ) { return c == 'h' || c == 'H'; }
 …
         size_t end = str.length() - 1;
         if ( posn == end ) { type = 3; return; }                        // no length after 'l' => long
         string::size_type next = posn + 1;                                      // advance to length
         if ( str[next] == '3' ) {                                                       // 32
 …
                 if ( str[i] == '1' ) v |= 1;
                 i += 1;
           if ( i == last - 1 || (str[i] != '0' && str[i] != '1') ) break;
+                if ( i == last - 1 || (str[i] != '0' && str[i] != '1') ) break;
                 v <<= 1;
         } // for
 } // scanbin
+Expression * build_constantInteger( string & str ) {
+        static const BasicType::Kind kind[2][6] = {
+ast::Expr * build_constantInteger(
+                const CodeLocation & location, string & str ) {
+        static const ast::BasicType::Kind kind[2][6] = {
                 // short (h) must be before char (hh) because shorter type has the longer suffix
                 { BasicType::ShortSignedInt, BasicType::SignedChar, BasicType::SignedInt, BasicType::LongSignedInt, BasicType::LongLongSignedInt, /* BasicType::SignedInt128 */ BasicType::LongLongSignedInt, },
                 { BasicType::ShortUnsignedInt, BasicType::UnsignedChar, BasicType::UnsignedInt, BasicType::LongUnsignedInt, BasicType::LongLongUnsignedInt, /* BasicType::UnsignedInt128 */ BasicType::LongLongUnsignedInt, },
+                { ast::BasicType::ShortSignedInt, ast::BasicType::SignedChar, ast::BasicType::SignedInt, ast::BasicType::LongSignedInt, ast::BasicType::LongLongSignedInt, /* BasicType::SignedInt128 */ ast::BasicType::LongLongSignedInt, },
+                { ast::BasicType::ShortUnsignedInt, ast::BasicType::UnsignedChar, ast::BasicType::UnsignedInt, ast::BasicType::LongUnsignedInt, ast::BasicType::LongLongUnsignedInt, /* BasicType::UnsignedInt128 */ ast::BasicType::LongLongUnsignedInt, },
         };
 …
         string str2( "0x0" );
         unsigned long long int v, v2 = 0;                                       // converted integral value
         Expression * ret, * ret2;
+        ast::Expr * ret, * ret2;
         int type = -1;                                                                          // 0 => short, 1 => char, 2 => int, 3 => long int, 4 => long long int, 5 => int128
 …
         // special constants
         if ( str == "0" ) {
                 ret = new ConstantExpr( Constant( (Type *)new ZeroType( noQualifiers ), str, (unsigned long long int)0 ) );
+                ret = new ast::ConstantExpr( location, new ast::ZeroType(), str, 0 );
                 goto CLEANUP;
         } // if
         if ( str == "1" ) {
                 ret = new ConstantExpr( Constant( (Type *)new OneType( noQualifiers ), str, (unsigned long long int)1 ) );
+                ret = new ast::ConstantExpr( location, new ast::OneType(), str, 1 );
                 goto CLEANUP;
         } // if
-        string::size_type posn;
         // 'u' can appear before or after length suffix
 …
         } else {
                 // At least one digit in integer constant, so safe to backup while looking for suffix.
+                posn = str.find_last_of( "pP" );                                // pointer value
+                if ( posn != string::npos ) { ltype = 5; str.erase( posn, 1 ); goto FINI; }
+                posn = str.find_last_of( "zZ" );                                // size_t
+                if ( posn != string::npos ) { Unsigned = true; type = 2; ltype = 4; str.erase( posn, 1 ); goto FINI; }
+                posn = str.rfind( "hh" );                                               // char
+                if ( posn != string::npos ) { type = 1; str.erase( posn, 2 ); goto FINI; }
+                posn = str.rfind( "HH" );                                               // char
+                if ( posn != string::npos ) { type = 1; str.erase( posn, 2 ); goto FINI; }
+                posn = str.find_last_of( "hH" );                                // short
+                if ( posn != string::npos ) { type = 0; str.erase( posn, 1 ); goto FINI; }
+                posn = str.find_last_of( "nN" );                                // int (natural number)
+                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"
+          FINI: ;
+                // This declaration and the comma expressions in the conditions mimic
+                // the declare and check pattern allowed in later compiler versions.
+                // (Only some early compilers/C++ standards do not support it.)
+                string::size_type posn;
+                // pointer value
+                if ( posn = str.find_last_of( "pP" ), posn != string::npos ) {
+                        ltype = 5; str.erase( posn, 1 );
+                // size_t
+                } else if ( posn = str.find_last_of( "zZ" ), posn != string::npos ) {
+                        Unsigned = true; type = 2; ltype = 4; str.erase( posn, 1 );
+                // signed char
+                } else if ( posn = str.rfind( "hh" ), posn != string::npos ) {
+                        type = 1; str.erase( posn, 2 );
+                // signed char
+                } else if ( posn = str.rfind( "HH" ), posn != string::npos ) {
+                        type = 1; str.erase( posn, 2 );
+                // short
+                } else if ( posn = str.find_last_of( "hH" ), posn != string::npos ) {
+                        type = 0; str.erase( posn, 1 );
+                // int (natural number)
+                } else if ( posn = str.find_last_of( "nN" ), posn != string::npos ) {
+                        type = 2; str.erase( posn, 1 );
+                } else if ( str.rfind( "ll" ) != string::npos || str.rfind( "LL" ) != string::npos ) {
+                        type = 4;
+                } else {
+                        lnthSuffix( str, type, ltype );
+                } // if
         } // if
 …
         if ( type == 5 ) SemanticError( yylloc, "int128 constant is not supported on this target " + str );
 #endif // ! __SIZEOF_INT128__
         if ( str[0] == '0' ) {                                                          // radix character ?
                 dec = false;
 …
                                 unsigned int len = str.length();
                                 if ( len > (2 + 16 + 16) ) SemanticError( yylloc, "128-bit hexadecimal constant to large " + str );
+                          if ( len <= (2 + 16) ) goto FHEX1;            // hex digits < 2^64
+                                str2 = "0x" + str.substr( len - 16 );
+                                sscanf( (char *)str2.c_str(), "%llx", &v2 );
+                                str = str.substr( 0, len - 16 );
+                          FHEX1: ;
+                                // hex digits < 2^64
+                                if ( len > (2 + 16) ) {
+                                        str2 = "0x" + str.substr( len - 16 );
+                                        sscanf( (char *)str2.c_str(), "%llx", &v2 );
+                                        str = str.substr( 0, len - 16 );
+                                } // if
                                 sscanf( (char *)str.c_str(), "%llx", &v );
 #endif // __SIZEOF_INT128__
 …
         // Constant type is correct for overload resolving.
+        ret = new ConstantExpr( Constant( new BasicType( noQualifiers, kind[Unsigned][type] ), str, v ) );
+        ret = new ast::ConstantExpr( location,
+                new ast::BasicType( kind[Unsigned][type] ), str, v );
         if ( Unsigned && type < 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 );
+                ret = new ast::CastExpr( location,
+                        ret,
+                        new ast::BasicType( kind[Unsigned][type] ),
+                        ast::ExplicitCast );
         } else if ( ltype != -1 ) {                                                     // explicit length ?
                 if ( ltype == 6 ) {                                                             // int128, (int128)constant
+//                      ret = new CastExpr( ret, new BasicType( Type::Qualifiers(), kind[Unsigned][type] ), false );
+                        ret2 = new ConstantExpr( Constant( new BasicType( noQualifiers, BasicType::LongLongSignedInt ), str2, v2 ) );
+                        ret = build_compoundLiteral( DeclarationNode::newBasicType( DeclarationNode::Int128 )->addType( DeclarationNode::newSignedNess( DeclarationNode::Unsigned ) ),
+                                                                                 new InitializerNode( (InitializerNode *)(new InitializerNode( new ExpressionNode( v2 == 0 ? ret2 : ret ) ))->set_last( new InitializerNode( new ExpressionNode( v2 == 0 ? ret : ret2 ) ) ), true ) );
+                        ret2 = new ast::ConstantExpr( location,
+                                new ast::BasicType( ast::BasicType::LongLongSignedInt ),
+                                str2,
+                                v2 );
+                        ret = build_compoundLiteral( location,
+                                DeclarationNode::newBasicType(
+                                        DeclarationNode::Int128
+                                )->addType(
+                                        DeclarationNode::newSignedNess( DeclarationNode::Unsigned ) ),
+                                new InitializerNode(
+                                        (InitializerNode *)(new InitializerNode( new ExpressionNode( v2 == 0 ? ret2 : ret ) ))->set_last( new InitializerNode( new ExpressionNode( v2 == 0 ? ret : ret2 ) ) ), true )
+                        );
                 } else {                                                                                // explicit length, (length_type)constant
+                        ret = new CastExpr( ret, new TypeInstType( Type::Qualifiers(), lnthsInt[Unsigned][ltype], false ), false );
+                        ret = new ast::CastExpr( location,
+                                ret,
+                                new ast::TypeInstType( lnthsInt[Unsigned][ltype], ast::TypeDecl::Dtype ),
+                                ast::ExplicitCast );
                         if ( ltype == 5 ) {                                                     // pointer, intptr( (uintptr_t)constant )
+                                ret = build_func( new ExpressionNode( build_varref( new string( "intptr" ) ) ), new ExpressionNode( ret ) );
+                                ret = build_func( location,
+                                        new ExpressionNode(
+                                                build_varref( location, new string( "intptr" ) ) ),
+                                        new ExpressionNode( ret ) );
                         } // if
                 } // if
 …
+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::NUMBER_OF_BASIC_TYPES, BasicType::NUMBER_OF_BASIC_TYPES, BasicType::uFloat16Complex, BasicType::uFloat32Complex, BasicType::uFloat32xComplex, BasicType::uFloat64Complex, BasicType::uFloat64xComplex, BasicType::uFloat128Complex, BasicType::uFloat128xComplex },
+ast::Expr * build_constantFloat(
+                const CodeLocation & location, string & str ) {
+        static const ast::BasicType::Kind kind[2][12] = {
+                { ast::BasicType::Float, ast::BasicType::Double, ast::BasicType::LongDouble, ast::BasicType::uuFloat80, ast::BasicType::uuFloat128, ast::BasicType::uFloat16, ast::BasicType::uFloat32, ast::BasicType::uFloat32x, ast::BasicType::uFloat64, ast::BasicType::uFloat64x, ast::BasicType::uFloat128, ast::BasicType::uFloat128x },
+                { ast::BasicType::FloatComplex, ast::BasicType::DoubleComplex, ast::BasicType::LongDoubleComplex, ast::BasicType::NUMBER_OF_BASIC_TYPES, ast::BasicType::NUMBER_OF_BASIC_TYPES, ast::BasicType::uFloat16Complex, ast::BasicType::uFloat32Complex, ast::BasicType::uFloat32xComplex, ast::BasicType::uFloat64Complex, ast::BasicType::uFloat64xComplex, ast::BasicType::uFloat128Complex, ast::BasicType::uFloat128xComplex },
         };
 …
         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 );
+        ast::Expr * ret = new ast::ConstantExpr( location,
+                new ast::BasicType( kind[complx][type] ),
+                str,
+                v );
+        // explicit length ?
+        if ( explnth ) {
+                ret = new ast::CastExpr( location,
+                        ret,
+                        new ast::BasicType( kind[complx][type] ),
+                        ast::ExplicitCast );
         } // if
 …
 } // sepString
 Expression * build_constantChar( string & str ) {
+ast::Expr * build_constantChar( const CodeLocation & location, string & str ) {
         string units;                                                                           // units
         sepString( str, units, '\'' );                                          // separate constant from units
+        Expression * ret = new ConstantExpr( Constant( new BasicType( noQualifiers, BasicType::Char ), str, (unsigned long long int)(unsigned char)str[1] ) );
+        ast::Expr * ret = new ast::ConstantExpr( location,
+                new ast::BasicType( ast::BasicType::Char ),
+                str,
+                (unsigned long long int)(unsigned char)str[1] );
         if ( units.length() != 0 ) {
+                ret = new UntypedExpr( new NameExpr( units ), { ret } );
+                ret = new ast::UntypedExpr( location,
+                        new ast::NameExpr( location, units ),
+                        { ret } );
         } // if
 …
 } // build_constantChar
+Expression * build_constantStr( string & str ) {
+ast::Expr * build_constantStr(
+                const CodeLocation & location,
+                string & str ) {
         assert( str.length() > 0 );
         string units;                                                                           // units
         sepString( str, units, '"' );                                           // separate constant from units
         Type * strtype;
+        ast::Type * strtype;
         switch ( str[0] ) {                                                                     // str has >= 2 characters, i.e, null string "" => safe to look at subscripts 0/1
           case 'u':
+        case 'u':
                 if ( str[1] == '8' ) goto Default;                              // utf-8 characters => array of char
                 // lookup type of associated typedef
                 strtype = new TypeInstType( Type::Qualifiers( ), "char16_t", false );
+                strtype = new ast::TypeInstType( "char16_t", ast::TypeDecl::Dtype );
                 break;
           case 'U':
                 strtype = new TypeInstType( Type::Qualifiers( ), "char32_t", false );
+        case 'U':
+                strtype = new ast::TypeInstType( "char32_t", ast::TypeDecl::Dtype );
                 break;
           case 'L':
                 strtype = new TypeInstType( Type::Qualifiers( ), "wchar_t", false );
+        case 'L':
+                strtype = new ast::TypeInstType( "wchar_t", ast::TypeDecl::Dtype );
                 break;
           Default:                                                                                      // char default string type
           default:
                 strtype = new BasicType( Type::Qualifiers( ), BasicType::Char );
+        Default:                                                                                        // char default string type
+        default:
+                strtype = new ast::BasicType( ast::BasicType::Char );
         } // switch
+        ArrayType * at = new ArrayType( noQualifiers, strtype,
+                                                                        new ConstantExpr( Constant::from_ulong( str.size() + 1 - 2 ) ), // +1 for '\0' and -2 for '"'
+                                                                        false, false );
+        Expression * ret = new ConstantExpr( Constant( at, str, std::nullopt ) );
+        ast::ArrayType * at = new ast::ArrayType(
+                strtype,
+                // Length is adjusted: +1 for '\0' and -2 for '"'
+                ast::ConstantExpr::from_ulong( location, str.size() + 1 - 2 ),
+                ast::FixedLen,
+                ast::DynamicDim );
+        ast::Expr * ret = new ast::ConstantExpr( location, at, str, std::nullopt );
         if ( units.length() != 0 ) {
+                ret = new UntypedExpr( new NameExpr( units ), { ret } );
+                ret = new ast::UntypedExpr( location,
+                        new ast::NameExpr( location, units ),
+                        { ret } );
         } // if
 …
 } // build_constantStr
+Expression * build_field_name_FLOATING_FRACTIONconstant( const string & str ) {
+ast::Expr * build_field_name_FLOATING_FRACTIONconstant(
+                const CodeLocation & location, const string & str ) {
         if ( str.find_first_not_of( "0123456789", 1 ) != string::npos ) SemanticError( yylloc, "invalid tuple index " + str );
+        Expression * ret = build_constantInteger( *new string( str.substr(1) ) );
+        ast::Expr * ret = build_constantInteger( location,
+                *new string( str.substr(1) ) );
         delete &str;
         return ret;
 } // build_field_name_FLOATING_FRACTIONconstant
+Expression * build_field_name_FLOATING_DECIMALconstant( const string & str ) {
+ast::Expr * build_field_name_FLOATING_DECIMALconstant(
+                const CodeLocation & location, const string & str ) {
         if ( str[str.size() - 1] != '.' ) SemanticError( yylloc, "invalid tuple index " + str );
+        Expression * ret = build_constantInteger( *new string( str.substr( 0, str.size()-1 ) ) );
+        ast::Expr * ret = build_constantInteger(
+                location, *new string( str.substr( 0, str.size()-1 ) ) );
         delete &str;
         return ret;
 } // build_field_name_FLOATING_DECIMALconstant
+Expression * build_field_name_FLOATINGconstant( const string & str ) {
+ast::Expr * build_field_name_FLOATINGconstant( const CodeLocation & location,
+                const string & str ) {
         // str is of the form A.B -> separate at the . and return member expression
         int a, b;
 …
         stringstream ss( str );
         ss >> a >> dot >> b;
+        UntypedMemberExpr * ret = new UntypedMemberExpr( new ConstantExpr( Constant::from_int( b ) ), new ConstantExpr( Constant::from_int( a ) ) );
+        auto ret = new ast::UntypedMemberExpr( location,
+                ast::ConstantExpr::from_int( location, b ),
+                ast::ConstantExpr::from_int( location, a )
+        );
         delete &str;
         return ret;
 } // build_field_name_FLOATINGconstant
+Expression * make_field_name_fraction_constants( Expression * fieldName, Expression * fracts ) {
+        if ( fracts ) {
+                if ( UntypedMemberExpr * memberExpr = dynamic_cast< UntypedMemberExpr * >( fracts ) ) {
+                        memberExpr->set_member( make_field_name_fraction_constants( fieldName, memberExpr->get_aggregate() ) );
+                        return memberExpr;
+                } else {
+                        return new UntypedMemberExpr( fracts, fieldName );
+                } // if
+        } // if
+        return fieldName;
+ast::Expr * make_field_name_fraction_constants( const CodeLocation & location,
+                ast::Expr * fieldName,
+                ast::Expr * fracts ) {
+        if ( nullptr == fracts ) {
+                return fieldName;
+        } else if ( auto memberExpr = dynamic_cast<ast::UntypedMemberExpr *>( fracts ) ) {
+                memberExpr->member = make_field_name_fraction_constants( location,
+                        fieldName,
+                        ast::mutate( memberExpr->aggregate.get() ) );
+                return memberExpr;
+        } else {
+                return new ast::UntypedMemberExpr( location, fracts, fieldName );
+        } // if
 } // make_field_name_fraction_constants
+Expression * build_field_name_fraction_constants( Expression * fieldName, ExpressionNode * fracts ) {
+        return make_field_name_fraction_constants( fieldName, maybeMoveBuild< Expression >( fracts ) );
+ast::Expr * build_field_name_fraction_constants( const CodeLocation & location,
+                ast::Expr * fieldName,
+                ExpressionNode * fracts ) {
+        return make_field_name_fraction_constants( location, fieldName, maybeMoveBuild( fracts ) );
 } // build_field_name_fraction_constants
+NameExpr * build_varref( const string * name ) {
+        NameExpr * expr = new NameExpr( *name );
+ast::NameExpr * build_varref( const CodeLocation & location,
+                const string * name ) {
+        ast::NameExpr * expr = new ast::NameExpr( location, *name );
         delete name;
         return expr;
 } // build_varref
+QualifiedNameExpr * build_qualified_expr( const DeclarationNode * decl_node, const NameExpr * name ) {
+        Declaration * newDecl = maybeBuild< Declaration >(decl_node);
+        if ( DeclarationWithType * newDeclWithType = dynamic_cast< DeclarationWithType * >( newDecl ) ) {
+                const Type * t = newDeclWithType->get_type();
+                if ( t ) {
+                        if ( const TypeInstType * typeInst = dynamic_cast<const TypeInstType *>( t ) ) {
+                                newDecl= new EnumDecl( typeInst->name );
+ast::QualifiedNameExpr * build_qualified_expr( const CodeLocation & location,
+                const DeclarationNode * decl_node,
+                const ast::NameExpr * name ) {
+        ast::Decl * newDecl = maybeBuild( decl_node );
+        if ( ast::DeclWithType * newDeclWithType = dynamic_cast<ast::DeclWithType *>( newDecl ) ) {
+                if ( const ast::Type * t = newDeclWithType->get_type() ) {
+                        if ( auto typeInst = dynamic_cast<const ast::TypeInstType *>( t ) ) {
+                                newDecl = new ast::EnumDecl( location, typeInst->name );
+                        }
+                }
+        }
         return new QualifiedNameExpr( newDecl, name->name );
+        return new ast::QualifiedNameExpr( location, newDecl, name->name );
+}
+QualifiedNameExpr * build_qualified_expr( const EnumDecl * decl_node, const NameExpr * name ) {
+        EnumDecl * newDecl = const_cast< EnumDecl * >( decl_node );
+        return new QualifiedNameExpr( newDecl, name->name );
+ast::QualifiedNameExpr * build_qualified_expr( const CodeLocation & location,
+                const ast::EnumDecl * decl,
+                const ast::NameExpr * name ) {
+        return new ast::QualifiedNameExpr( location, decl, name->name );
+}
+DimensionExpr * build_dimensionref( const string * name ) {
+        DimensionExpr * expr = new DimensionExpr( *name );
+ast::DimensionExpr * build_dimensionref( const CodeLocation & location,
+                const string * name ) {
+        ast::DimensionExpr * expr = new ast::DimensionExpr( location, *name );
         delete name;
         return expr;
 …
 }; // OperName
+Expression * build_cast( DeclarationNode * decl_node, ExpressionNode * expr_node, CastExpr::CastKind kind ) {
+        Type * targetType = maybeMoveBuildType( decl_node );
+        if ( dynamic_cast< VoidType * >( targetType ) ) {
+ast::Expr * build_cast( const CodeLocation & location,
+                DeclarationNode * decl_node,
+                ExpressionNode * expr_node,
+                ast::CastExpr::CastKind kind ) {
+        ast::Type * targetType = maybeMoveBuildType( decl_node );
+        if ( dynamic_cast<ast::VoidType *>( targetType ) ) {
                 delete targetType;
+                return new CastExpr( maybeMoveBuild< Expression >(expr_node), false, kind );
+                return new ast::CastExpr( location,
+                        maybeMoveBuild( expr_node ),
+                        ast::ExplicitCast, kind );
         } else {
+                return new CastExpr( maybeMoveBuild< Expression >(expr_node), targetType, false, kind );
+                return new ast::CastExpr( location,
+                        maybeMoveBuild( expr_node ),
+                        targetType,
+                        ast::ExplicitCast, kind );
         } // if
 } // build_cast
+Expression * build_keyword_cast( AggregateDecl::Aggregate target, ExpressionNode * expr_node ) {
+        return new KeywordCastExpr( maybeMoveBuild< Expression >(expr_node), target );
+ast::Expr * build_keyword_cast( const CodeLocation & location,
+                ast::AggregateDecl::Aggregate target,
+                ExpressionNode * expr_node ) {
+        return new ast::KeywordCastExpr( location,
+                maybeMoveBuild( expr_node ),
+                target
+        );
+}
+Expression * build_virtual_cast( DeclarationNode * decl_node, ExpressionNode * expr_node ) {
+        return new VirtualCastExpr( maybeMoveBuild< Expression >( expr_node ), maybeMoveBuildType( decl_node ) );
+ast::Expr * build_virtual_cast( const CodeLocation & location,
+                DeclarationNode * decl_node,
+                ExpressionNode * expr_node ) {
+        return new ast::VirtualCastExpr( location,
+                maybeMoveBuild( expr_node ),
+                maybeMoveBuildType( decl_node )
+        );
 } // build_virtual_cast
+Expression * build_fieldSel( ExpressionNode * expr_node, Expression * member ) {
+        return new UntypedMemberExpr( member, maybeMoveBuild< Expression >(expr_node) );
+ast::Expr * build_fieldSel( const CodeLocation & location,
+                ExpressionNode * expr_node,
+                ast::Expr * member ) {
+        return new ast::UntypedMemberExpr( location,
+                member,
+                maybeMoveBuild( expr_node )
+        );
 } // build_fieldSel
+Expression * build_pfieldSel( ExpressionNode * expr_node, Expression * member ) {
+        UntypedExpr * deref = new UntypedExpr( new NameExpr( "*?" ) );
+ast::Expr * build_pfieldSel( const CodeLocation & location,
+                ExpressionNode * expr_node,
+                ast::Expr * member ) {
+        auto deref = new ast::UntypedExpr( location,
+                new ast::NameExpr( location, "*?" )
+        );
         deref->location = expr_node->location;
         deref->get_args().push_back( maybeMoveBuild< Expression >(expr_node) );
         UntypedMemberExpr * ret = new UntypedMemberExpr( member, deref );
+        deref->args.push_back( maybeMoveBuild( expr_node ) );
+        auto ret = new ast::UntypedMemberExpr( location, member, deref );
         return ret;
 } // build_pfieldSel
+Expression * build_offsetOf( DeclarationNode * decl_node, NameExpr * member ) {
+        Expression * ret = new UntypedOffsetofExpr( maybeMoveBuildType( decl_node ), member->get_name() );
+ast::Expr * build_offsetOf( const CodeLocation & location,
+                DeclarationNode * decl_node,
+                ast::NameExpr * member ) {
+        ast::Expr * ret = new ast::UntypedOffsetofExpr( location,
+                maybeMoveBuildType( decl_node ),
+                member->name
+        );
+        ret->result = new ast::BasicType( ast::BasicType::LongUnsignedInt );
         delete member;
         return ret;
 } // build_offsetOf
+Expression * build_and_or( ExpressionNode * expr_node1, ExpressionNode * expr_node2, bool kind ) {
+        return new LogicalExpr( notZeroExpr( maybeMoveBuild< Expression >(expr_node1) ), notZeroExpr( maybeMoveBuild< Expression >(expr_node2) ), kind );
+ast::Expr * build_and_or( const CodeLocation & location,
+                ExpressionNode * expr_node1,
+                ExpressionNode * expr_node2,
+                ast::LogicalFlag flag ) {
+        return new ast::LogicalExpr( location,
+                notZeroExpr( maybeMoveBuild( expr_node1 ) ),
+                notZeroExpr( maybeMoveBuild( expr_node2 ) ),
+                flag
+        );
 } // build_and_or
+Expression * build_unary_val( OperKinds op, ExpressionNode * expr_node ) {
+        list< Expression * > args;
+        args.push_back( maybeMoveBuild< Expression >(expr_node) );
+        return new UntypedExpr( new NameExpr( OperName[ (int)op ] ), args );
+ast::Expr * build_unary_val( const CodeLocation & location,
+                OperKinds op,
+                ExpressionNode * expr_node ) {
+        std::vector<ast::ptr<ast::Expr>> args;
+        args.push_back( maybeMoveBuild( expr_node ) );
+        return new ast::UntypedExpr( location,
+                new ast::NameExpr( location, OperName[ (int)op ] ),
+                std::move( args )
+        );
 } // build_unary_val
+Expression * build_unary_ptr( OperKinds op, ExpressionNode * expr_node ) {
         list< Expression * > args;
         args.push_back(  maybeMoveBuild< Expression >(expr_node) ); // xxx -- this is exactly the same as the val case now, refactor this code.
         return new UntypedExpr( new NameExpr( OperName[ (int)op ] ), args );
+} // build_unary_ptr
+Expression * build_binary_val( OperKinds op, ExpressionNode * expr_node1, ExpressionNode * expr_node2 ) {
         list< Expression * > args;
         args.push_back( maybeMoveBuild< Expression >(expr_node1) );
         args.push_back( maybeMoveBuild< Expression >(expr_node2) );
         return new UntypedExpr( new NameExpr( OperName[ (int)op ] ), args );
+ast::Expr * build_binary_val( const CodeLocation & location,
+                OperKinds op,
+                ExpressionNode * expr_node1,
+                ExpressionNode * expr_node2 ) {
+        std::vector<ast::ptr<ast::Expr>> args;
+        args.push_back( maybeMoveBuild( expr_node1 ) );
+        args.push_back( maybeMoveBuild( expr_node2 ) );
+        return new ast::UntypedExpr( location,
+                new ast::NameExpr( location, OperName[ (int)op ] ),
+                std::move( args )
+        );
 } // build_binary_val
+Expression * build_binary_ptr( OperKinds op, ExpressionNode * expr_node1, ExpressionNode * expr_node2 ) {
         list< Expression * > args;
         args.push_back( maybeMoveBuild< Expression >(expr_node1) );
         args.push_back( maybeMoveBuild< Expression >(expr_node2) );
         return new UntypedExpr( new NameExpr( OperName[ (int)op ] ), args );
+} // build_binary_ptr
+Expression * build_cond( ExpressionNode * expr_node1, ExpressionNode * expr_node2, ExpressionNode * expr_node3 ) {
         return new ConditionalExpr( notZeroExpr( maybeMoveBuild< Expression >(expr_node1) ), maybeMoveBuild< Expression >(expr_node2), maybeMoveBuild< Expression >(expr_node3) );
+ast::Expr * build_cond( const CodeLocation & location,
+                ExpressionNode * expr_node1,
+                ExpressionNode * expr_node2,
+                ExpressionNode * expr_node3 ) {
+        return new ast::ConditionalExpr( location,
+                notZeroExpr( maybeMoveBuild( expr_node1 ) ),
+                maybeMoveBuild( expr_node2 ),
+                maybeMoveBuild( expr_node3 )
+        );
 } // build_cond
+Expression * build_tuple( ExpressionNode * expr_node ) {
+        list< Expression * > exprs;
+ast::Expr * build_tuple( const CodeLocation & location,
+                ExpressionNode * expr_node ) {
+        std::vector<ast::ptr<ast::Expr>> exprs;
         buildMoveList( expr_node, exprs );
         return new UntypedTupleExpr( exprs );;
+        return new ast::UntypedTupleExpr( location, std::move( exprs ) );
 } // build_tuple
+Expression * build_func( ExpressionNode * function, ExpressionNode * expr_node ) {
+        list< Expression * > args;
+ast::Expr * build_func( const CodeLocation & location,
+                ExpressionNode * function,
+                ExpressionNode * expr_node ) {
+        std::vector<ast::ptr<ast::Expr>> args;
         buildMoveList( expr_node, args );
+        return new UntypedExpr( maybeMoveBuild< Expression >(function), args );
+        return new ast::UntypedExpr( location,
+                maybeMoveBuild( function ),
+                std::move( args )
+        );
 } // build_func
+Expression * build_compoundLiteral( DeclarationNode * decl_node, InitializerNode * kids ) {
+        Declaration * newDecl = maybeBuild< Declaration >(decl_node); // compound literal type
+        if ( DeclarationWithType * newDeclWithType = dynamic_cast< DeclarationWithType * >( newDecl ) ) { // non-sue compound-literal type
+                return new CompoundLiteralExpr( newDeclWithType->get_type(), maybeMoveBuild< Initializer >(kids) );
+ast::Expr * build_compoundLiteral( const CodeLocation & location,
+                DeclarationNode * decl_node,
+                InitializerNode * kids ) {
+        // compound literal type
+        ast::Decl * newDecl = maybeBuild( decl_node );
+        // non-sue compound-literal type
+        if ( ast::DeclWithType * newDeclWithType = dynamic_cast<ast::DeclWithType *>( newDecl ) ) {
+                return new ast::CompoundLiteralExpr( location,
+                        newDeclWithType->get_type(),
+                        maybeMoveBuild( kids ) );
         // these types do not have associated type information
+        } else if ( StructDecl * newDeclStructDecl = dynamic_cast< StructDecl * >( newDecl )  ) {
+                if ( newDeclStructDecl->has_body() ) {
+                        return new CompoundLiteralExpr( new StructInstType( Type::Qualifiers(), newDeclStructDecl ), maybeMoveBuild< Initializer >(kids) );
+        } else if ( auto newDeclStructDecl = dynamic_cast<ast::StructDecl *>( newDecl ) ) {
+                if ( newDeclStructDecl->body ) {
+                        return new ast::CompoundLiteralExpr( location,
+                                new ast::StructInstType( newDeclStructDecl ),
+                                maybeMoveBuild( kids ) );
                 } else {
+                        return new CompoundLiteralExpr( new StructInstType( Type::Qualifiers(), newDeclStructDecl->get_name() ), maybeMoveBuild< Initializer >(kids) );
+                } // if
+        } else if ( UnionDecl * newDeclUnionDecl = dynamic_cast< UnionDecl * >( newDecl )  ) {
+                if ( newDeclUnionDecl->has_body() ) {
+                        return new CompoundLiteralExpr( new UnionInstType( Type::Qualifiers(), newDeclUnionDecl ), maybeMoveBuild< Initializer >(kids) );
+                        return new ast::CompoundLiteralExpr( location,
+                                new ast::StructInstType( newDeclStructDecl->name ),
+                                maybeMoveBuild( kids ) );
+                } // if
+        } else if ( auto newDeclUnionDecl = dynamic_cast<ast::UnionDecl *>( newDecl )  ) {
+                if ( newDeclUnionDecl->body ) {
+                        return new ast::CompoundLiteralExpr( location,
+                                new ast::UnionInstType( newDeclUnionDecl ),
+                                maybeMoveBuild( kids ) );
                 } else {
+                        return new CompoundLiteralExpr( new UnionInstType( Type::Qualifiers(), newDeclUnionDecl->get_name() ), maybeMoveBuild< Initializer >(kids) );
+                } // if
+        } else if ( EnumDecl * newDeclEnumDecl = dynamic_cast< EnumDecl * >( newDecl )  ) {
+                if ( newDeclEnumDecl->has_body() ) {
+                        return new CompoundLiteralExpr( new EnumInstType( Type::Qualifiers(), newDeclEnumDecl ), maybeMoveBuild< Initializer >(kids) );
+                        return new ast::CompoundLiteralExpr( location,
+                                new ast::UnionInstType( newDeclUnionDecl->name ),
+                                maybeMoveBuild( kids ) );
+                } // if
+        } else if ( auto newDeclEnumDecl = dynamic_cast<ast::EnumDecl *>( newDecl )  ) {
+                if ( newDeclEnumDecl->body ) {
+                        return new ast::CompoundLiteralExpr( location,
+                                new ast::EnumInstType( newDeclEnumDecl ),
+                                maybeMoveBuild( kids ) );
                 } else {
+                        return new CompoundLiteralExpr( new EnumInstType( Type::Qualifiers(), newDeclEnumDecl->get_name() ), maybeMoveBuild< Initializer >(kids) );
+                        return new ast::CompoundLiteralExpr( location,
+                                new ast::EnumInstType( newDeclEnumDecl->name ),
+                                maybeMoveBuild( kids ) );
                 } // if
         } else {
 …
 // Local Variables: //
 // tab-width: 4 //
-// mode: c++ //
-// compile-command: "make install" //
 // End: //

src/Parser/InitializerNode.cc

-              r34b4268
+              r24d6572
 // Author           : Rodolfo G. Esteves
 // Created On       : Sat May 16 13:20:24 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Jul 28 23:27:20 2017
 // Update Count     : 26
+// Last Modified By : Andrew Beach
+// Last Modified On : Tue Apr  4 11:18:00 2023
+// Update Count     : 27
 //
+#include "InitializerNode.h"
 #include <iostream>                // for operator<<, ostream, basic_ostream
 …
 #include <string>                  // for operator<<, string
+#include "AST/Expr.hpp"            // for Expr
+#include "AST/Init.hpp"            // for Designator, Init, ListInit, Sing...
+#include "Common/SemanticError.h"  // for SemanticError
+#include "Common/utility.h"        // for maybeBuild
+#include "ExpressionNode.h"        // for ExpressionNode
+#include "DeclarationNode.h"       // for buildList
 using namespace std;
+#include "Common/SemanticError.h"  // for SemanticError
+#include "Common/utility.h"        // for maybeBuild
+#include "ParseNode.h"             // for InitializerNode, ExpressionNode
+#include "SynTree/Expression.h"    // for Expression
+#include "SynTree/Initializer.h"   // for Initializer, ListInit, SingleInit
+static ast::ConstructFlag toConstructFlag( bool maybeConstructed ) {
+        return maybeConstructed ? ast::MaybeConstruct : ast::NoConstruct;
+}
 InitializerNode::InitializerNode( ExpressionNode * _expr, bool aggrp, ExpressionNode * des )
 …
         if ( kids )
                 set_last( nullptr );
 } // InitializerNode::InitializerNode
+} // InitializerNode::InitializerNode
 InitializerNode::InitializerNode( InitializerNode * init, bool aggrp, ExpressionNode * des )
 …
 } // InitializerNode::printOneLine
 Initializer * InitializerNode::build() const {
+ast::Init * InitializerNode::build() const {
         assertf( ! isDelete, "Should not build delete stmt InitializerNode" );
         if ( aggregate ) {
                 // steal designators from children
                 std::list< Designation * > designlist;
+                std::vector<ast::ptr<ast::Designation>> designlist;
                 InitializerNode * child = next_init();
+                for ( ; child != nullptr; child = dynamic_cast< InitializerNode * >( child->get_next() ) ) {
+                        std::list< Expression * > desList;
+                        buildList< Expression, ExpressionNode >( child->designator, desList );
+                        designlist.push_back( new Designation( desList ) );
+                for ( ; child != nullptr ; child = dynamic_cast< InitializerNode * >( child->get_next() ) ) {
+                        std::deque<ast::ptr<ast::Expr>> desList;
+                        buildList( child->designator, desList );
+                        designlist.push_back(
+                                new ast::Designation( location, std::move( desList ) ) );
                 } // for
+                std::list< Initializer * > initlist;
+                buildList< Initializer, InitializerNode >( next_init(), initlist );
+                return new ListInit( initlist, designlist, maybeConstructed );
+        } else {
+                if ( get_expression() ) {
+                        assertf( get_expression()->expr, "The expression of initializer must have value" );
+                        return new SingleInit( maybeBuild< Expression >( get_expression() ), maybeConstructed );
+                } // if
+                std::vector<ast::ptr<ast::Init>> initlist;
+                buildList( next_init(), initlist );
+                return new ast::ListInit( location,
+                        std::move( initlist ),
+                        std::move( designlist ),
+                        toConstructFlag( maybeConstructed )
+                );
+        } else if ( get_expression() ) {
+                assertf( get_expression()->expr, "The expression of initializer must have value" );
+                return new ast::SingleInit( location,
+                        maybeBuild( get_expression() ),
+                        toConstructFlag( maybeConstructed )
+                );
         } // if
         return nullptr;

src/Parser/ParseNode.h

-              r34b4268
+              r24d6572
 // Author           : Rodolfo G. Esteves
 // Created On       : Sat May 16 13:28:16 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed Nov  2 21:27:07 2022
 // Update Count     : 939
+// Last Modified By : Andrew Beach
+// Last Modified On : Mon Apr  3 17:55:00 2023
+// Update Count     : 942
 //
 …
 #include <string>                  // for string
+#include "AST/Expr.hpp"            // for Expr, NameExpr LogicalFlag
+#include "AST/Fwd.hpp"             // for ptr, Decl, DeclWithType,
+#include "AST/Stmt.hpp"            // for Stmt
 #include "Common/CodeLocation.h"   // for CodeLocation
 #include "Common/SemanticError.h"  // for SemanticError
 #include "Common/UniqueName.h"     // for UniqueName
+#include "Common/utility.h"        // for maybeClone, maybeBuild
+#include "SynTree/LinkageSpec.h"   // for Spec
+#include "SynTree/Declaration.h"   // for Aggregate
+#include "SynTree/Expression.h"    // for Expression, ConstantExpr (ptr only)
+#include "SynTree/Label.h"         // for Label
+#include "SynTree/Statement.h"     // for Statement, BranchStmt, BranchStmt:...
+#include "SynTree/Type.h"          // for Type, Type::FuncSpecifiers, Type::...
+#include "Common/utility.h"        // for maybeClone
+#include "Parser/parserutility.h"  // for maybeBuild, maybeCopy
 class Attribute;
 …
 class DeclarationWithType;
 class Initializer;
+class InitializerNode;
 class ExpressionNode;
 struct StatementNode;
 …
 }; // ParseNode
-//##############################################################################
-class InitializerNode : public ParseNode {
-  public:
-        InitializerNode( ExpressionNode *, bool aggrp = false, ExpressionNode * des = nullptr );
-        InitializerNode( InitializerNode *, bool aggrp = false, ExpressionNode * des = nullptr );
-        InitializerNode( bool isDelete );
-        ~InitializerNode();
-        virtual InitializerNode * clone() const { assert( false ); return nullptr; }
-        ExpressionNode * get_expression() const { return expr; }
-        InitializerNode * set_designators( ExpressionNode * des ) { designator = des; return this; }
-        ExpressionNode * get_designators() const { return designator; }
-        InitializerNode * set_maybeConstructed( bool value ) { maybeConstructed = value; return this; }
-        bool get_maybeConstructed() const { return maybeConstructed; }
-        bool get_isDelete() const { return isDelete; }
-        InitializerNode * next_init() const { return kids; }
-        void print( std::ostream & os, int indent = 0 ) const;
-        void printOneLine( std::ostream & ) const;
-        virtual Initializer * build() const;
-  private:
-        ExpressionNode * expr;
-        bool aggregate;
-        ExpressionNode * designator;                                            // may be list
-        InitializerNode * kids;
-        bool maybeConstructed;
-        bool isDelete;
-}; // InitializerNode
-//##############################################################################
-class ExpressionNode final : public ParseNode {
-  public:
-        ExpressionNode( Expression * expr = nullptr ) : expr( expr ) {}
-        virtual ~ExpressionNode() {}
-        virtual ExpressionNode * clone() const override { return expr ? static_cast<ExpressionNode*>((new ExpressionNode( expr->clone() ))->set_next( maybeClone( get_next() ) )) : nullptr; }
-        bool get_extension() const { return extension; }
-        ExpressionNode * set_extension( bool exten ) { extension = exten; return this; }
-        virtual void print( std::ostream & os, __attribute__((unused)) int indent = 0 ) const override {
-                os << expr.get();
+        }
-        void printOneLine( __attribute__((unused)) std::ostream & os, __attribute__((unused)) int indent = 0 ) const {}
-        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;
-}; // ExpressionNode
-template< typename T >
-struct maybeBuild_t< Expression, T > {
-        static inline Expression * doit( const T * orig ) {
-                if ( orig ) {
-                        Expression * p = orig->build();
-                        p->set_extension( orig->get_extension() );
-                        p->location = orig->location;
-                        return p;
-                } else {
-                        return nullptr;
-                } // if
+        }
-};
 // Must harmonize with OperName.
 enum class OperKinds {
 …
 struct LabelNode {
         std::list< Label > labels;
+        std::vector<ast::Label> labels;
 };
-Expression * build_constantInteger( std::string & str ); // these 4 routines modify the string
-Expression * build_constantFloat( std::string & str );
-Expression * build_constantChar( std::string & str );
-Expression * build_constantStr( std::string & str );
-Expression * build_field_name_FLOATING_FRACTIONconstant( const std::string & str );
-Expression * build_field_name_FLOATING_DECIMALconstant( const std::string & str );
-Expression * build_field_name_FLOATINGconstant( const std::string & str );
-Expression * build_field_name_fraction_constants( Expression * fieldName, ExpressionNode * fracts );
-NameExpr * build_varref( const std::string * name );
-QualifiedNameExpr * build_qualified_expr( const DeclarationNode * decl_node, const NameExpr * name );
-QualifiedNameExpr * build_qualified_expr( const EnumDecl * decl, const NameExpr * name );
-DimensionExpr * build_dimensionref( const std::string * name );
-Expression * build_cast( DeclarationNode * decl_node, ExpressionNode * expr_node, CastExpr::CastKind kind = CastExpr::Default );
-Expression * build_keyword_cast( AggregateDecl::Aggregate target, ExpressionNode * expr_node );
-Expression * build_virtual_cast( DeclarationNode * decl_node, ExpressionNode * expr_node );
-Expression * build_fieldSel( ExpressionNode * expr_node, Expression * member );
-Expression * build_pfieldSel( ExpressionNode * expr_node, Expression * member );
-Expression * build_offsetOf( DeclarationNode * decl_node, NameExpr * member );
-Expression * build_and( ExpressionNode * expr_node1, ExpressionNode * expr_node2 );
-Expression * build_and_or( ExpressionNode * expr_node1, ExpressionNode * expr_node2, bool kind );
-Expression * build_unary_val( OperKinds op, ExpressionNode * expr_node );
-Expression * build_unary_ptr( OperKinds op, ExpressionNode * expr_node );
-Expression * build_binary_val( OperKinds op, ExpressionNode * expr_node1, ExpressionNode * expr_node2 );
-Expression * build_binary_ptr( OperKinds op, ExpressionNode * expr_node1, ExpressionNode * expr_node2 );
-Expression * build_cond( ExpressionNode * expr_node1, ExpressionNode * expr_node2, ExpressionNode * expr_node3 );
-Expression * build_tuple( ExpressionNode * expr_node = nullptr );
-Expression * build_func( ExpressionNode * function, ExpressionNode * expr_node );
-Expression * build_compoundLiteral( DeclarationNode * decl_node, InitializerNode * kids );
-//##############################################################################
-struct TypeData;
-struct DeclarationNode : public ParseNode {
-        // 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 };
-        static const char * basicTypeNames[];
-        enum ComplexType { Complex, NoComplexType, Imaginary }; // Imaginary unsupported => parse, but make invisible and print error message
-        static const char * complexTypeNames[];
-        enum Signedness { Signed, Unsigned, NoSignedness };
-        static const char * signednessNames[];
-        enum Length { Short, Long, LongLong, NoLength };
-        static const char * lengthNames[];
-        enum BuiltinType { Valist, AutoType, Zero, One, NoBuiltinType };
-        static const char * builtinTypeNames[];
-        static DeclarationNode * newStorageClass( Type::StorageClasses );
-        static DeclarationNode * newFuncSpecifier( Type::FuncSpecifiers );
-        static DeclarationNode * newTypeQualifier( Type::Qualifiers );
-        static DeclarationNode * newBasicType( BasicType );
-        static DeclarationNode * newComplexType( ComplexType );
-        static DeclarationNode * newSignedNess( Signedness );
-        static DeclarationNode * newLength( Length );
-        static DeclarationNode * newBuiltinType( BuiltinType );
-        static DeclarationNode * newForall( DeclarationNode * );
-        static DeclarationNode * newFromTypedef( const std::string * );
-        static DeclarationNode * newFromGlobalScope();
-        static DeclarationNode * newQualifiedType( DeclarationNode *, DeclarationNode * );
-        static DeclarationNode * newFunction( const std::string * name, DeclarationNode * ret, DeclarationNode * param, StatementNode * body );
-        static DeclarationNode * newAggregate( AggregateDecl::Aggregate kind, const std::string * name, ExpressionNode * actuals, DeclarationNode * fields, bool body );
-        static DeclarationNode * newEnum( const std::string * name, DeclarationNode * constants, bool body, bool typed, DeclarationNode * base = nullptr, EnumHiding hiding = EnumHiding::Visible );
-        static DeclarationNode * newEnumConstant( const std::string * name, ExpressionNode * constant );
-        static DeclarationNode * newEnumValueGeneric( const std::string * name, InitializerNode * init );
-        static DeclarationNode * newEnumInLine( const std::string name );
-        static DeclarationNode * newName( const std::string * );
-        static DeclarationNode * newFromTypeGen( const std::string *, ExpressionNode * params );
-        static DeclarationNode * newTypeParam( TypeDecl::Kind, const std::string * );
-        static DeclarationNode * newTrait( const std::string * name, DeclarationNode * params, DeclarationNode * asserts );
-        static DeclarationNode * newTraitUse( const std::string * name, ExpressionNode * params );
-        static DeclarationNode * newTypeDecl( const std::string * name, DeclarationNode * typeParams );
-        static DeclarationNode * newPointer( DeclarationNode * qualifiers, OperKinds kind );
-        static DeclarationNode * newArray( ExpressionNode * size, DeclarationNode * qualifiers, bool isStatic );
-        static DeclarationNode * newVarArray( DeclarationNode * qualifiers );
-        static DeclarationNode * newBitfield( ExpressionNode * size );
-        static DeclarationNode * newTuple( DeclarationNode * members );
-        static DeclarationNode * newTypeof( ExpressionNode * expr, bool basetypeof = false );
-        static DeclarationNode * newVtableType( DeclarationNode * expr );
-        static DeclarationNode * newAttribute( const std::string *, ExpressionNode * expr = nullptr ); // gcc attributes
-        static DeclarationNode * newDirectiveStmt( StatementNode * stmt ); // gcc external directive statement
-        static DeclarationNode * newAsmStmt( StatementNode * stmt ); // gcc external asm statement
-        static DeclarationNode * newStaticAssert( ExpressionNode * condition, Expression * message );
-        DeclarationNode();
-        ~DeclarationNode();
-        DeclarationNode * clone() const override;
-        DeclarationNode * addQualifiers( DeclarationNode * );
-        void checkQualifiers( const TypeData *, const TypeData * );
-        void checkSpecifiers( DeclarationNode * );
-        DeclarationNode * copySpecifiers( DeclarationNode * );
-        DeclarationNode * addType( DeclarationNode * );
-        DeclarationNode * addTypedef();
-        DeclarationNode * addEnumBase( DeclarationNode * );
-        DeclarationNode * addAssertions( DeclarationNode * );
-        DeclarationNode * addName( std::string * );
-        DeclarationNode * addAsmName( DeclarationNode * );
-        DeclarationNode * addBitfield( ExpressionNode * size );
-        DeclarationNode * addVarArgs();
-        DeclarationNode * addFunctionBody( StatementNode * body, ExpressionNode * with = nullptr );
-        DeclarationNode * addOldDeclList( DeclarationNode * list );
-        DeclarationNode * setBase( TypeData * newType );
-        DeclarationNode * copyAttribute( DeclarationNode * attr );
-        DeclarationNode * addPointer( DeclarationNode * qualifiers );
-        DeclarationNode * addArray( DeclarationNode * array );
-        DeclarationNode * addNewPointer( DeclarationNode * pointer );
-        DeclarationNode * addNewArray( DeclarationNode * array );
-        DeclarationNode * addParamList( DeclarationNode * list );
-        DeclarationNode * addIdList( DeclarationNode * list ); // old-style functions
-        DeclarationNode * addInitializer( InitializerNode * init );
-        DeclarationNode * addTypeInitializer( DeclarationNode * init );
-        DeclarationNode * cloneType( std::string * newName );
-        DeclarationNode * cloneBaseType( DeclarationNode * newdecl );
-        DeclarationNode * appendList( DeclarationNode * node ) {
-                return (DeclarationNode *)set_last( node );
+        }
-        virtual void print( __attribute__((unused)) std::ostream & os, __attribute__((unused)) int indent = 0 ) const override;
-        virtual void printList( __attribute__((unused)) std::ostream & os, __attribute__((unused)) int indent = 0 ) const override;
-        Declaration * build() const;
-        Type * buildType() const;
-        LinkageSpec::Spec get_linkage() const { return linkage; }
-        DeclarationNode * extractAggregate() const;
-        bool has_enumeratorValue() const { return (bool)enumeratorValue; }
-        ExpressionNode * consume_enumeratorValue() const { return const_cast<DeclarationNode *>(this)->enumeratorValue.release(); }
-        bool get_extension() const { return extension; }
-        DeclarationNode * set_extension( bool exten ) { extension = exten; return this; }
-        bool get_inLine() const { return inLine; }
-        DeclarationNode * set_inLine( bool inL ) { inLine = inL; return this; }
-        DeclarationNode * get_last() { return (DeclarationNode *)ParseNode::get_last(); }
-        struct Variable_t {
-//              const std::string * name;
-                TypeDecl::Kind tyClass;
-                DeclarationNode * assertions;
-                DeclarationNode * initializer;
-        };
-        Variable_t variable;
-        struct Attr_t {
-//              const std::string * name;
-                ExpressionNode * expr;
-                DeclarationNode * type;
-        };
-        Attr_t attr;
-        struct StaticAssert_t {
-                ExpressionNode * condition;
-                Expression * message;
-        };
-        StaticAssert_t assert;
-        BuiltinType builtin = NoBuiltinType;
-        TypeData * type = nullptr;
-        bool inLine = false;
-        bool enumInLine = false;
-        Type::FuncSpecifiers funcSpecs;
-        Type::StorageClasses storageClasses;
-        ExpressionNode * bitfieldWidth = nullptr;
-        std::unique_ptr<ExpressionNode> enumeratorValue;
-        bool hasEllipsis = false;
-        LinkageSpec::Spec linkage;
-        Expression * asmName = nullptr;
-        std::list< Attribute * > attributes;
-        InitializerNode * initializer = nullptr;
-        bool extension = false;
-        std::string error;
-        StatementNode * asmStmt = nullptr;
-        StatementNode * directiveStmt = nullptr;
-        static UniqueName anonymous;
-}; // DeclarationNode
-Type * buildType( TypeData * type );
-static inline Type * maybeMoveBuildType( const DeclarationNode * orig ) {
-        Type * ret = orig ? orig->buildType() : nullptr;
-        delete orig;
-        return ret;
+}
-//##############################################################################
-struct StatementNode final : public ParseNode {
-        StatementNode() { stmt = nullptr; }
-        StatementNode( Statement * stmt ) : stmt( stmt ) {}
-        StatementNode( DeclarationNode * decl );
-        virtual ~StatementNode() {}
-        virtual StatementNode * clone() const final { assert( false ); return nullptr; }
-        Statement * build() const { return const_cast<StatementNode *>(this)->stmt.release(); }
-        virtual StatementNode * add_label( const std::string * name, DeclarationNode * attr = nullptr ) {
-                stmt->get_labels().emplace_back( * name, nullptr, attr ? std::move( attr->attributes ) : std::list< Attribute * > {} );
-                delete attr;
-                delete name;
-                return this;
+        }
-        virtual StatementNode * append_last_case( StatementNode * );
-        virtual void print( std::ostream & os, __attribute__((unused)) int indent = 0 ) const override {
-                os << stmt.get() << std::endl;
+        }
-        std::unique_ptr<Statement> stmt;
-}; // StatementNode
-Statement * build_expr( ExpressionNode * ctl );
-struct CondCtl {
-        CondCtl( DeclarationNode * decl, ExpressionNode * condition ) :
-                init( decl ? new StatementNode( decl ) : nullptr ), condition( condition ) {}
-        StatementNode * init;
-        ExpressionNode * condition;
-};
-struct ForCtrl {
-        ForCtrl( ExpressionNode * expr, ExpressionNode * condition, ExpressionNode * change ) :
-                init( new StatementNode( build_expr( expr ) ) ), condition( condition ), change( change ) {}
-        ForCtrl( DeclarationNode * decl, ExpressionNode * condition, ExpressionNode * change ) :
-                init( new StatementNode( decl ) ), condition( condition ), change( change ) {}
-        StatementNode * init;
-        ExpressionNode * condition;
-        ExpressionNode * change;
-};
-Expression * build_if_control( CondCtl * ctl, std::list< Statement * > & init );
-Statement * build_if( CondCtl * ctl, StatementNode * then, StatementNode * else_ );
-Statement * build_switch( bool isSwitch, ExpressionNode * ctl, StatementNode * stmt );
-Statement * build_case( ExpressionNode * ctl );
-Statement * build_default();
-Statement * build_while( CondCtl * ctl, StatementNode * stmt, StatementNode * else_ = nullptr );
-Statement * build_do_while( ExpressionNode * ctl, StatementNode * stmt, StatementNode * else_ = nullptr );
-Statement * build_for( ForCtrl * forctl, StatementNode * stmt, StatementNode * else_ = nullptr );
-Statement * build_branch( BranchStmt::Type kind );
-Statement * build_branch( std::string * identifier, BranchStmt::Type kind );
-Statement * build_computedgoto( ExpressionNode * ctl );
-Statement * build_return( ExpressionNode * ctl );
-Statement * build_throw( ExpressionNode * ctl );
-Statement * build_resume( ExpressionNode * ctl );
-Statement * build_resume_at( ExpressionNode * ctl , ExpressionNode * target );
-Statement * build_try( StatementNode * try_, StatementNode * catch_, StatementNode * finally_ );
-Statement * build_catch( CatchStmt::Kind kind, DeclarationNode * decl, ExpressionNode * cond, StatementNode * body );
-Statement * build_finally( StatementNode * stmt );
-Statement * build_compound( StatementNode * first );
-StatementNode * maybe_build_compound( StatementNode * first );
-Statement * build_asm( bool voltile, Expression * instruction, ExpressionNode * output = nullptr, ExpressionNode * input = nullptr, ExpressionNode * clobber = nullptr, LabelNode * gotolabels = nullptr );
-Statement * build_directive( std::string * directive );
-SuspendStmt * build_suspend( StatementNode *, SuspendStmt::Type = SuspendStmt::None);
-WaitForStmt * build_waitfor( ExpressionNode * target, StatementNode * stmt, ExpressionNode * when );
-WaitForStmt * build_waitfor( ExpressionNode * target, StatementNode * stmt, ExpressionNode * when, WaitForStmt * existing );
-WaitForStmt * build_waitfor_timeout( ExpressionNode * timeout, StatementNode * stmt, ExpressionNode * when );
-WaitForStmt * build_waitfor_timeout( ExpressionNode * timeout, StatementNode * stmt, ExpressionNode * when, StatementNode * else_stmt, ExpressionNode * else_when );
-Statement * build_with( ExpressionNode * exprs, StatementNode * stmt );
-Statement * build_mutex( ExpressionNode * exprs, StatementNode * stmt );
-//##############################################################################
-template< typename SynTreeType, typename NodeType, template< typename, typename...> class Container, typename... Args >
-void buildList( const NodeType * firstNode, Container< SynTreeType *, Args... > & outputList ) {
-        SemanticErrorException errors;
-        std::back_insert_iterator< Container< SynTreeType *, Args... > > out( outputList );
-        const NodeType * cur = firstNode;
-        while ( cur ) {
-                try {
-                        SynTreeType * result = dynamic_cast< SynTreeType * >( maybeBuild< typename std::pointer_traits< decltype(cur->build())>::element_type >( cur ) );
-                        if ( result ) {
-                                result->location = cur->location;
-                                * out++ = result;
-                        } else {
-                                SemanticError( cur->location, "type specifier declaration in forall clause is currently unimplemented." );
-                        } // if
-                } catch( SemanticErrorException & e ) {
-                        errors.append( e );
-                } // try
-                const ParseNode * temp = (cur->get_next());
-                cur = dynamic_cast< const NodeType * >( temp ); // should not return nullptr
-                if ( ! cur && temp ) {                                                  // non-homogeneous nodes ?
-                        SemanticError( temp->location, "internal error, non-homogeneous nodes founds in buildList processing." );
-                } // if
-        } // while
-        if ( ! errors.isEmpty() ) {
-                throw errors;
-        } // if
+}
-// in DeclarationNode.cc
-void buildList( const DeclarationNode * firstNode, std::list< Declaration * > & outputList );
-void buildList( const DeclarationNode * firstNode, std::list< DeclarationWithType * > & outputList );
-void buildTypeList( const DeclarationNode * firstNode, std::list< Type * > & outputList );
-template< typename SynTreeType, typename NodeType >
-void buildMoveList( const NodeType * firstNode, std::list< SynTreeType * > & outputList ) {
-        buildList( firstNode, outputList );
-        delete firstNode;
+}
-// in ParseNode.cc
 std::ostream & operator<<( std::ostream & out, const ParseNode * node );

src/Parser/ParserTypes.h

-              r34b4268
+              r24d6572
 // The contents of this file are covered under the licence agreement in the
 // file "LICENCE" distributed with Cforall.
 //
 // parser.hh --
 //
+//
+// parser.hh --
+//
 // Author           : Peter A. Buhr
 // Created On       : Sat Sep 22 08:58:10 2001

src/Parser/StatementNode.cc

-              r34b4268
+              r24d6572
 // Author           : Rodolfo G. Esteves
 // Created On       : Sat May 16 14:59:41 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed Feb  2 20:29:30 2022
 // Update Count     : 425
+// Last Modified By : Andrew Beach
+// Last Modified On : Tue Apr 11 10:16:00 2023
+// Update Count     : 428
 //
+#include "StatementNode.h"
 #include <cassert>                 // for assert, strict_dynamic_cast, assertf
-#include <list>                    // for list
 #include <memory>                  // for unique_ptr
 #include <string>                  // for string
+#include "AST/Label.hpp"           // for Label
+#include "AST/Stmt.hpp"            // for Stmt, AsmStmt, BranchStmt, CaseCla...
 #include "Common/SemanticError.h"  // for SemanticError
 #include "Common/utility.h"        // for maybeMoveBuild, maybeBuild
+#include "ParseNode.h"             // for StatementNode, ExpressionNode, bui...
+#include "SynTree/Expression.h"    // for Expression, ConstantExpr
+#include "SynTree/Label.h"         // for Label, noLabels
+#include "SynTree/Declaration.h"
+#include "SynTree/Statement.h"     // for Statement, BranchStmt, CaseStmt
+#include "DeclarationNode.h"       // for DeclarationNode
+#include "ExpressionNode.h"        // for ExpressionNode
 #include "parserutility.h"         // for notZeroExpr
 …
 using namespace std;
+// Some helpers for cases that really want a single node but check for lists.
+static const ast::Stmt * buildMoveSingle( StatementNode * node ) {
+        std::vector<ast::ptr<ast::Stmt>> list;
+        buildMoveList( node, list );
+        assertf( list.size() == 1, "CFA Internal Error: Extra/Missing Nodes" );
+        return list.front().release();
+}
+static const ast::Stmt * buildMoveOptional( StatementNode * node ) {
+        std::vector<ast::ptr<ast::Stmt>> list;
+        buildMoveList( node, list );
+        assertf( list.size() <= 1, "CFA Internal Error: Extra Nodes" );
+        return list.empty() ? nullptr : list.front().release();
+}
 StatementNode::StatementNode( DeclarationNode * decl ) {
 …
         DeclarationNode * agg = decl->extractAggregate();
         if ( agg ) {
+                StatementNode * nextStmt = new StatementNode( new DeclStmt( maybeBuild< Declaration >( decl ) ) );
+                StatementNode * nextStmt = new StatementNode(
+                        new ast::DeclStmt( decl->location, maybeBuild( decl ) ) );
                 set_next( nextStmt );
                 if ( decl->get_next() ) {
 …
                 agg = decl;
         } // if
+        stmt.reset( new DeclStmt( maybeMoveBuild< Declaration >(agg) ) );
+        // Local copy to avoid accessing the pointer after it is moved from.
+        CodeLocation declLocation = agg->location;
+        stmt.reset( new ast::DeclStmt( declLocation, maybeMoveBuild( agg ) ) );
 } // StatementNode::StatementNode
+StatementNode * StatementNode::append_last_case( StatementNode * stmt ) {
+        StatementNode * prev = this;
+StatementNode * StatementNode::add_label(
+                const CodeLocation & location,
+                const std::string * name,
+                DeclarationNode * attr ) {
+        stmt->labels.emplace_back( location,
+                *name,
+                attr ? std::move( attr->attributes )
+                        : std::vector<ast::ptr<ast::Attribute>>{} );
+        delete attr;
+        delete name;
+        return this;
+}
+ClauseNode * ClauseNode::append_last_case( StatementNode * stmt ) {
+        ClauseNode * prev = this;
         // find end of list and maintain previous pointer
         for ( StatementNode * curr = prev; curr != nullptr; curr = (StatementNode *)curr->get_next() ) {
                 StatementNode * node = strict_dynamic_cast< StatementNode * >(curr);
                 assert( dynamic_cast< CaseStmt * >(node->stmt.get()) );
+        for ( ClauseNode * curr = prev; curr != nullptr; curr = (ClauseNode *)curr->get_next() ) {
+                ClauseNode * node = strict_dynamic_cast< ClauseNode * >(curr);
+                assert( dynamic_cast<ast::CaseClause *>( node->clause.get() ) );
                 prev = curr;
         } // for
+        ClauseNode * node = dynamic_cast< ClauseNode * >(prev);
         // convert from StatementNode list to Statement list
+        StatementNode * node = dynamic_cast< StatementNode * >(prev);
+        list< Statement * > stmts;
+        std::vector<ast::ptr<ast::Stmt>> stmts;
         buildMoveList( stmt, stmts );
         // splice any new Statements to end of current Statements
+        CaseStmt * caseStmt = dynamic_cast< CaseStmt * >(node->stmt.get());
+        caseStmt->get_statements().splice( caseStmt->get_statements().end(), stmts );
+        auto caseStmt = strict_dynamic_cast<ast::CaseClause *>( node->clause.get() );
+        for ( auto const & newStmt : stmts ) {
+                caseStmt->stmts.emplace_back( newStmt );
+        }
+        stmts.clear();
         return this;
+} // StatementNode::append_last_case
+Statement * build_expr( ExpressionNode * ctl ) {
+        Expression * e = maybeMoveBuild< Expression >( ctl );
+        if ( e ) return new ExprStmt( e );
+        else return new NullStmt();
+} // ClauseNode::append_last_case
+ast::Stmt * build_expr( CodeLocation const & location, ExpressionNode * ctl ) {
+        if ( ast::Expr * e = maybeMoveBuild( ctl ) ) {
+                return new ast::ExprStmt( location, e );
+        } else {
+                return new ast::NullStmt( location );
+        }
 } // build_expr
+Expression * build_if_control( CondCtl * ctl, list< Statement * > & init ) {
+        if ( ctl->init != 0 ) {
+                buildMoveList( ctl->init, init );
+static ast::Expr * build_if_control( CondCtl * ctl,
+                std::vector<ast::ptr<ast::Stmt>> & inits ) {
+        assert( inits.empty() );
+        if ( nullptr != ctl->init ) {
+                buildMoveList( ctl->init, inits );
         } // if
         Expression * cond = nullptr;
+        ast::Expr * cond = nullptr;
         if ( ctl->condition ) {
                 // compare the provided condition against 0
                 cond = notZeroExpr( maybeMoveBuild< Expression >(ctl->condition) );
+                cond = notZeroExpr( maybeMoveBuild( ctl->condition ) );
         } else {
                 for ( Statement * stmt : init ) {
+                for ( ast::ptr<ast::Stmt> & stmt : inits ) {
                         // build the && of all of the declared variables compared against 0
                         DeclStmt * declStmt = strict_dynamic_cast< DeclStmt * >( stmt );
                         DeclarationWithType * dwt = strict_dynamic_cast< DeclarationWithType * >( declStmt->decl );
                         Expression * nze = notZeroExpr( new VariableExpr( dwt ) );
                         cond = cond ? new LogicalExpr( cond, nze, true ) : nze;
+                        auto declStmt = stmt.strict_as<ast::DeclStmt>();
+                        auto dwt = declStmt->decl.strict_as<ast::DeclWithType>();
+                        ast::Expr * nze = notZeroExpr( new ast::VariableExpr( dwt->location, dwt ) );
+                        cond = cond ? new ast::LogicalExpr( dwt->location, cond, nze, ast::AndExpr ) : nze;
+                }
+        }
 …
 } // build_if_control
+Statement * build_if( CondCtl * ctl, StatementNode * then, StatementNode * else_ ) {
+        list< Statement * > astinit;                                            // maybe empty
+        Expression * astcond = build_if_control( ctl, astinit ); // ctl deleted, cond/init set
+        Statement * astthen, * astelse = nullptr;
+        list< Statement * > aststmt;
+        buildMoveList< Statement, StatementNode >( then, aststmt );
+        assert( aststmt.size() == 1 );
+        astthen = aststmt.front();
+        if ( else_ ) {
+                list< Statement * > aststmt;
+                buildMoveList< Statement, StatementNode >( else_, aststmt );
+                assert( aststmt.size() == 1 );
+                astelse = aststmt.front();
+        } // if
+        return new IfStmt( astcond, astthen, astelse, astinit );
+ast::Stmt * build_if( const CodeLocation & location, CondCtl * ctl, StatementNode * then, StatementNode * else_ ) {
+        std::vector<ast::ptr<ast::Stmt>> astinit;                                               // maybe empty
+        ast::Expr * astcond = build_if_control( ctl, astinit ); // ctl deleted, cond/init set
+        ast::Stmt const * astthen = buildMoveSingle( then );
+        ast::Stmt const * astelse = buildMoveOptional( else_ );
+        return new ast::IfStmt( location, astcond, astthen, astelse,
+                std::move( astinit )
+        );
 } // build_if
+Statement * build_switch( bool isSwitch, ExpressionNode * ctl, StatementNode * stmt ) {
+        list< Statement * > aststmt;
+        buildMoveList< Statement, StatementNode >( stmt, aststmt );
+        if ( ! isSwitch ) {                                                                     // choose statement
+                for ( Statement * stmt : aststmt ) {
+                        CaseStmt * caseStmt = strict_dynamic_cast< CaseStmt * >( stmt );
+                        if ( ! caseStmt->stmts.empty() ) {                      // code after "case" => end of case list
+                                CompoundStmt * block = strict_dynamic_cast< CompoundStmt * >( caseStmt->stmts.front() );
+                                block->kids.push_back( new BranchStmt( "", BranchStmt::Break ) );
+ast::Stmt * build_switch( const CodeLocation & location, bool isSwitch, ExpressionNode * ctl, ClauseNode * stmt ) {
+        std::vector<ast::ptr<ast::CaseClause>> aststmt;
+        buildMoveList( stmt, aststmt );
+        // If it is not a switch it is a choose statement.
+        if ( ! isSwitch ) {
+                for ( ast::ptr<ast::CaseClause> & stmt : aststmt ) {
+                        // Code after "case" is the end of case list.
+                        if ( !stmt->stmts.empty() ) {
+                                auto mutStmt = ast::mutate( stmt.get() );
+                                // I believe the stmts are actually always one block.
+                                auto stmts = mutStmt->stmts.front().get_and_mutate();
+                                auto block = strict_dynamic_cast<ast::CompoundStmt *>( stmts );
+                                block->kids.push_back( new ast::BranchStmt( block->location,
+                                        ast::BranchStmt::Break,
+                                        ast::Label( block->location ) ) );
+                                stmt = mutStmt;
                         } // if
                 } // for
         } // if
         // aststmt.size() == 0 for switch (...) {}, i.e., no declaration or statements
+        return new SwitchStmt( maybeMoveBuild< Expression >(ctl), aststmt );
+        return new ast::SwitchStmt( location,
+                maybeMoveBuild( ctl ), std::move( aststmt ) );
 } // build_switch
+Statement * build_case( ExpressionNode * ctl ) {
+        return new CaseStmt( maybeMoveBuild< Expression >(ctl), {} ); // stmt starts empty and then added to
+ast::CaseClause * build_case( const CodeLocation & location, ExpressionNode * ctl ) {
+        // stmt starts empty and then added to
+        auto expr = maybeMoveBuild( ctl );
+        return new ast::CaseClause( location, expr, {} );
 } // build_case
+Statement * build_default() {
+        return new CaseStmt( nullptr, {}, true );                       // stmt starts empty and then added to
+ast::CaseClause * build_default( const CodeLocation & location ) {
+        // stmt starts empty and then added to
+        return new ast::CaseClause( location, nullptr, {} );
 } // build_default
+Statement * build_while( CondCtl * ctl, StatementNode * stmt, StatementNode * else_ ) {
+        list< Statement * > astinit;                                            // maybe empty
+        Expression * astcond = build_if_control( ctl, astinit ); // ctl deleted, cond/init set
+        list< Statement * > aststmt;                                            // loop body, compound created if empty
+        buildMoveList< Statement, StatementNode >( stmt, aststmt );
+        assert( aststmt.size() == 1 );
+        list< Statement * > astelse;                                            // else clause, maybe empty
+        buildMoveList< Statement, StatementNode >( else_, astelse );
+        return new WhileDoStmt( astcond, aststmt.front(), astelse.front(), astinit, false );
+ast::Stmt * build_while( const CodeLocation & location, CondCtl * ctl, StatementNode * stmt, StatementNode * else_ ) {
+        std::vector<ast::ptr<ast::Stmt>> astinit;                                               // maybe empty
+        ast::Expr * astcond = build_if_control( ctl, astinit ); // ctl deleted, cond/init set
+        return new ast::WhileDoStmt( location,
+                astcond,
+                buildMoveSingle( stmt ),
+                buildMoveOptional( else_ ),
+                std::move( astinit ),
+                ast::While
+        );
 } // build_while
+Statement * build_do_while( ExpressionNode * ctl, StatementNode * stmt, StatementNode * else_ ) {
+        list< Statement * > aststmt;                                            // loop body, compound created if empty
+        buildMoveList< Statement, StatementNode >( stmt, aststmt );
+        assert( aststmt.size() == 1 );                                          // compound created if empty
+        list< Statement * > astelse;                                            // else clause, maybe empty
+        buildMoveList< Statement, StatementNode >( else_, astelse );
+ast::Stmt * build_do_while( const CodeLocation & location, ExpressionNode * ctl, StatementNode * stmt, StatementNode * else_ ) {
         // do-while cannot have declarations in the contitional, so init is always empty
+        return new WhileDoStmt( notZeroExpr( maybeMoveBuild< Expression >(ctl) ), aststmt.front(), astelse.front(), {}, true );
+        return new ast::WhileDoStmt( location,
+                notZeroExpr( maybeMoveBuild( ctl ) ),
+                buildMoveSingle( stmt ),
+                buildMoveOptional( else_ ),
+                {},
+                ast::DoWhile
+        );
 } // build_do_while
 Statement * build_for( ForCtrl * forctl, StatementNode * stmt, StatementNode * else_ ) {
         list< Statement * > astinit;                                            // maybe empty
+ast::Stmt * build_for( const CodeLocation & location, ForCtrl * forctl, StatementNode * stmt, StatementNode * else_ ) {
+        std::vector<ast::ptr<ast::Stmt>> astinit;                                               // maybe empty
         buildMoveList( forctl->init, astinit );
         Expression * astcond = nullptr;                                         // maybe empty
         astcond = notZeroExpr( maybeMoveBuild< Expression >(forctl->condition) );
         Expression * astincr = nullptr;                                         // maybe empty
         astincr = maybeMoveBuild< Expression >(forctl->change);
+        ast::Expr * astcond = nullptr;                                          // maybe empty
+        astcond = notZeroExpr( maybeMoveBuild( forctl->condition ) );
+        ast::Expr * astincr = nullptr;                                          // maybe empty
+        astincr = maybeMoveBuild( forctl->change );
         delete forctl;
+        list< Statement * > aststmt;                                            // loop body, compound created if empty
+        buildMoveList< Statement, StatementNode >( stmt, aststmt );
+        assert( aststmt.size() == 1 );
+        list< Statement * > astelse;                                            // else clause, maybe empty
+        buildMoveList< Statement, StatementNode >( else_, astelse );
+        return new ForStmt( astinit, astcond, astincr, aststmt.front(), astelse.front() );
+        return new ast::ForStmt( location,
+                std::move( astinit ),
+                astcond,
+                astincr,
+                buildMoveSingle( stmt ),
+                buildMoveOptional( else_ )
+        );
 } // build_for
+Statement * build_branch( BranchStmt::Type kind ) {
+        Statement * ret = new BranchStmt( "", kind );
+        return ret;
+ast::Stmt * build_branch( const CodeLocation & location, ast::BranchStmt::Kind kind ) {
+        return new ast::BranchStmt( location,
+                kind,
+                ast::Label( location )
+        );
 } // build_branch
+Statement * build_branch( string * identifier, BranchStmt::Type kind ) {
+        Statement * ret = new BranchStmt( * identifier, kind );
+ast::Stmt * build_branch( const CodeLocation & location, string * identifier, ast::BranchStmt::Kind kind ) {
+        ast::Stmt * ret = new ast::BranchStmt( location,
+                kind,
+                ast::Label( location, *identifier )
+        );
         delete identifier;                                                                      // allocated by lexer
         return ret;
 } // build_branch
+Statement * build_computedgoto( ExpressionNode * ctl ) {
+        return new BranchStmt( maybeMoveBuild< Expression >(ctl), BranchStmt::Goto );
+ast::Stmt * build_computedgoto( ExpressionNode * ctl ) {
+        ast::Expr * expr = maybeMoveBuild( ctl );
+        return new ast::BranchStmt( expr->location, expr );
 } // build_computedgoto
 Statement * build_return( ExpressionNode * ctl ) {
         list< Expression * > exps;
+ast::Stmt * build_return( const CodeLocation & location, ExpressionNode * ctl ) {
+        std::vector<ast::ptr<ast::Expr>> exps;
         buildMoveList( ctl, exps );
+        return new ReturnStmt( exps.size() > 0 ? exps.back() : nullptr );
+        return new ast::ReturnStmt( location,
+                exps.size() > 0 ? exps.back().release() : nullptr
+        );
 } // build_return
+Statement * build_throw( ExpressionNode * ctl ) {
+        list< Expression * > exps;
+static ast::Stmt * build_throw_stmt(
+                const CodeLocation & location,
+                ExpressionNode * ctl,
+                ast::ExceptionKind kind ) {
+        std::vector<ast::ptr<ast::Expr>> exps;
         buildMoveList( ctl, exps );
         assertf( exps.size() < 2, "CFA internal error: leaking memory" );
+        return new ThrowStmt( ThrowStmt::Terminate, !exps.empty() ? exps.back() : nullptr );
+        return new ast::ThrowStmt( location,
+                kind,
+                !exps.empty() ? exps.back().release() : nullptr,
+                (ast::Expr *)nullptr
+        );
+}
+ast::Stmt * build_throw( const CodeLocation & loc, ExpressionNode * ctl ) {
+        return build_throw_stmt( loc, ctl, ast::Terminate );
 } // build_throw
+Statement * build_resume( ExpressionNode * ctl ) {
+        list< Expression * > exps;
+        buildMoveList( ctl, exps );
+        assertf( exps.size() < 2, "CFA internal error: leaking memory" );
+        return new ThrowStmt( ThrowStmt::Resume, !exps.empty() ? exps.back() : nullptr );
+ast::Stmt * build_resume( const CodeLocation & loc, ExpressionNode * ctl ) {
+        return build_throw_stmt( loc, ctl, ast::Resume );
 } // build_resume
 Statement * build_resume_at( ExpressionNode * ctl, ExpressionNode * target ) {
+ast::Stmt * build_resume_at( ExpressionNode * ctl, ExpressionNode * target ) {
         (void)ctl;
         (void)target;
 …
 } // build_resume_at
+Statement * build_try( StatementNode * try_, StatementNode * catch_, StatementNode * finally_ ) {
+        list< CatchStmt * > aststmt;
+        buildMoveList< CatchStmt, StatementNode >( catch_, aststmt );
+        CompoundStmt * tryBlock = strict_dynamic_cast< CompoundStmt * >(maybeMoveBuild< Statement >(try_));
+        FinallyStmt * finallyBlock = dynamic_cast< FinallyStmt * >(maybeMoveBuild< Statement >(finally_) );
+        return new TryStmt( tryBlock, aststmt, finallyBlock );
+ast::Stmt * build_try( const CodeLocation & location, StatementNode * try_, ClauseNode * catch_, ClauseNode * finally_ ) {
+        std::vector<ast::ptr<ast::CatchClause>> aststmt;
+        buildMoveList( catch_, aststmt );
+        ast::CompoundStmt * tryBlock = strict_dynamic_cast<ast::CompoundStmt *>( maybeMoveBuild( try_ ) );
+        ast::FinallyClause * finallyBlock = nullptr;
+        if ( finally_ ) {
+                finallyBlock = dynamic_cast<ast::FinallyClause *>( finally_->clause.release() );
+        }
+        return new ast::TryStmt( location,
+                tryBlock,
+                std::move( aststmt ),
+                finallyBlock
+        );
 } // build_try
+Statement * build_catch( CatchStmt::Kind kind, DeclarationNode * decl, ExpressionNode * cond, StatementNode * body ) {
+        list< Statement * > aststmt;
+        buildMoveList< Statement, StatementNode >( body, aststmt );
+        assert( aststmt.size() == 1 );
+        return new CatchStmt( kind, maybeMoveBuild< Declaration >(decl), maybeMoveBuild< Expression >(cond), aststmt.front() );
+ast::CatchClause * build_catch( const CodeLocation & location, ast::ExceptionKind kind, DeclarationNode * decl, ExpressionNode * cond, StatementNode * body ) {
+        return new ast::CatchClause( location,
+                kind,
+                maybeMoveBuild( decl ),
+                maybeMoveBuild( cond ),
+                buildMoveSingle( body )
+        );
 } // build_catch
+Statement * build_finally( StatementNode * stmt ) {
+        list< Statement * > aststmt;
+        buildMoveList< Statement, StatementNode >( stmt, aststmt );
+        assert( aststmt.size() == 1 );
+        return new FinallyStmt( dynamic_cast< CompoundStmt * >( aststmt.front() ) );
+ast::FinallyClause * build_finally( const CodeLocation & location, StatementNode * stmt ) {
+        return new ast::FinallyClause( location,
+                strict_dynamic_cast<const ast::CompoundStmt *>(
+                        buildMoveSingle( stmt )
+                )
+        );
 } // build_finally
+SuspendStmt * build_suspend( StatementNode * then, SuspendStmt::Type type ) {
+        auto node = new SuspendStmt();
+        node->type = type;
+        list< Statement * > stmts;
+        buildMoveList< Statement, StatementNode >( then, stmts );
+        if(!stmts.empty()) {
+                assert( stmts.size() == 1 );
+                node->then = dynamic_cast< CompoundStmt * >( stmts.front() );
+        }
+        return node;
+}
+WaitForStmt * build_waitfor( ExpressionNode * targetExpr, StatementNode * stmt, ExpressionNode * when ) {
+        auto node = new WaitForStmt();
+        WaitForStmt::Target target;
+        target.function = maybeBuild<Expression>( targetExpr );
+ast::SuspendStmt * build_suspend( const CodeLocation & location, StatementNode * then, ast::SuspendStmt::Kind kind ) {
+        return new ast::SuspendStmt( location,
+                strict_dynamic_cast<const ast::CompoundStmt *, nullptr>(
+                        buildMoveOptional( then )
+                ),
+                kind
+        );
+} // build_suspend
+ast::WaitForStmt * build_waitfor( const CodeLocation & location, ast::WaitForStmt * existing, ExpressionNode * when, ExpressionNode * targetExpr, StatementNode * stmt ) {
+        auto clause = new ast::WaitForClause( location );
+        clause->target = maybeBuild( targetExpr );
+        clause->stmt = maybeMoveBuild( stmt );
+        clause->when_cond = notZeroExpr( maybeMoveBuild( when ) );
         ExpressionNode * next = dynamic_cast<ExpressionNode *>( targetExpr->get_next() );
         targetExpr->set_next( nullptr );
         buildMoveList< Expression >( next, target.arguments );
+        buildMoveList( next, clause->target_args );
         delete targetExpr;
+        node->clauses.push_back( WaitForStmt::Clause{
+                target,
+                maybeMoveBuild<Statement >( stmt ),
+                notZeroExpr( maybeMoveBuild<Expression>( when ) )
+        });
+        return node;
+        existing->clauses.insert( existing->clauses.begin(), clause );
+        return existing;
 } // build_waitfor
+WaitForStmt * build_waitfor( ExpressionNode * targetExpr, StatementNode * stmt, ExpressionNode * when, WaitForStmt * node ) {
+        WaitForStmt::Target target;
+        target.function = maybeBuild<Expression>( targetExpr );
+        ExpressionNode * next = dynamic_cast<ExpressionNode *>( targetExpr->get_next() );
+        targetExpr->set_next( nullptr );
+        buildMoveList< Expression >( next, target.arguments );
+        delete targetExpr;
+        node->clauses.insert( node->clauses.begin(), WaitForStmt::Clause{
+                std::move( target ),
+                maybeMoveBuild<Statement >( stmt ),
+                notZeroExpr( maybeMoveBuild<Expression>( when ) )
+        });
+        return node;
+} // build_waitfor
+WaitForStmt * build_waitfor_timeout( ExpressionNode * timeout, StatementNode * stmt, ExpressionNode * when ) {
+        auto node = new WaitForStmt();
+        if( timeout ) {
+                node->timeout.time      = maybeMoveBuild<Expression>( timeout );
+                node->timeout.statement = maybeMoveBuild<Statement >( stmt    );
+                node->timeout.condition = notZeroExpr( maybeMoveBuild<Expression>( when ) );
+        } else {
+                node->orelse.statement  = maybeMoveBuild<Statement >( stmt );
+                node->orelse.condition  = notZeroExpr( maybeMoveBuild<Expression>( when ) );
+        } // if
+        return node;
+ast::WaitForStmt * build_waitfor_else( const CodeLocation & location, ast::WaitForStmt * existing, ExpressionNode * when, StatementNode * stmt ) {
+        existing->else_stmt = maybeMoveBuild( stmt );
+        existing->else_cond = notZeroExpr( maybeMoveBuild( when ) );
+        (void)location;
+        return existing;
+} // build_waitfor_else
+ast::WaitForStmt * build_waitfor_timeout( const CodeLocation & location, ast::WaitForStmt * existing, ExpressionNode * when, ExpressionNode * timeout, StatementNode * stmt ) {
+        existing->timeout_time = maybeMoveBuild( timeout );
+        existing->timeout_stmt = maybeMoveBuild( stmt );
+        existing->timeout_cond = notZeroExpr( maybeMoveBuild( when ) );
+        (void)location;
+        return existing;
 } // build_waitfor_timeout
+WaitForStmt * build_waitfor_timeout( ExpressionNode * timeout, StatementNode * stmt, ExpressionNode * when,  StatementNode * else_, ExpressionNode * else_when ) {
+        auto node = new WaitForStmt();
+        node->timeout.time      = maybeMoveBuild<Expression>( timeout );
+        node->timeout.statement = maybeMoveBuild<Statement >( stmt    );
+        node->timeout.condition = notZeroExpr( maybeMoveBuild<Expression>( when ) );
+        node->orelse.statement  = maybeMoveBuild<Statement >( else_ );
+        node->orelse.condition  = notZeroExpr( maybeMoveBuild<Expression>( else_when ) );
+        return node;
+} // build_waitfor_timeout
+Statement * build_with( ExpressionNode * exprs, StatementNode * stmt ) {
+        list< Expression * > e;
+ast::WaitUntilStmt::ClauseNode * build_waituntil_clause( const CodeLocation & loc, ExpressionNode * when, ExpressionNode * targetExpr, StatementNode * stmt ) {
+    ast::WhenClause * clause = new ast::WhenClause( loc );
+    clause->when_cond = notZeroExpr( maybeMoveBuild( when ) );
+    clause->stmt = maybeMoveBuild( stmt );
+    clause->target = maybeMoveBuild( targetExpr );
+    return new ast::WaitUntilStmt::ClauseNode( clause );
+}
+ast::WaitUntilStmt::ClauseNode * build_waituntil_else( const CodeLocation & loc, ExpressionNode * when, StatementNode * stmt ) {
+    ast::WhenClause * clause = new ast::WhenClause( loc );
+    clause->when_cond = notZeroExpr( maybeMoveBuild( when ) );
+    clause->stmt = maybeMoveBuild( stmt );
+    return new ast::WaitUntilStmt::ClauseNode( ast::WaitUntilStmt::ClauseNode::Op::ELSE, clause );
+}
+ast::WaitUntilStmt::ClauseNode * build_waituntil_timeout( const CodeLocation & loc, ExpressionNode * when, ExpressionNode * timeout, StatementNode * stmt ) {
+    ast::WhenClause * clause = new ast::WhenClause( loc );
+    clause->when_cond = notZeroExpr( maybeMoveBuild( when ) );
+    clause->stmt = maybeMoveBuild( stmt );
+    clause->target = maybeMoveBuild( timeout );
+    return new ast::WaitUntilStmt::ClauseNode( ast::WaitUntilStmt::ClauseNode::Op::TIMEOUT, clause );
+}
+ast::WaitUntilStmt * build_waituntil_stmt( const CodeLocation & loc, ast::WaitUntilStmt::ClauseNode * root ) {
+    ast::WaitUntilStmt * retStmt = new ast::WaitUntilStmt( loc );
+    retStmt->predicateTree = root;
+    // iterative tree traversal
+    std::vector<ast::WaitUntilStmt::ClauseNode *> nodeStack; // stack needed for iterative traversal
+    ast::WaitUntilStmt::ClauseNode * currNode = nullptr;
+    ast::WaitUntilStmt::ClauseNode * lastInternalNode = nullptr;
+    ast::WaitUntilStmt::ClauseNode * cleanup = nullptr; // used to cleanup removed else/timeout
+    nodeStack.push_back(root);
+    do {
+        currNode = nodeStack.back();
+        nodeStack.pop_back(); // remove node since it will be processed
+        switch (currNode->op) {
+            case ast::WaitUntilStmt::ClauseNode::LEAF:
+                retStmt->clauses.push_back(currNode->leaf);
+                break;
+            case ast::WaitUntilStmt::ClauseNode::ELSE:
+                retStmt->else_stmt = currNode->leaf->stmt
+                    ? ast::deepCopy( currNode->leaf->stmt )
+                    : nullptr;
+                retStmt->else_cond = currNode->leaf->when_cond
+                    ? ast::deepCopy( currNode->leaf->when_cond )
+                    : nullptr;
+                delete currNode->leaf;
+                break;
+            case ast::WaitUntilStmt::ClauseNode::TIMEOUT:
+                retStmt->timeout_time = currNode->leaf->target
+                    ? ast::deepCopy( currNode->leaf->target )
+                    : nullptr;
+                retStmt->timeout_stmt = currNode->leaf->stmt
+                    ? ast::deepCopy( currNode->leaf->stmt )
+                    : nullptr;
+                retStmt->timeout_cond = currNode->leaf->when_cond
+                    ? ast::deepCopy( currNode->leaf->when_cond )
+                    : nullptr;
+                delete currNode->leaf;
+                break;
+            default:
+                nodeStack.push_back( currNode->right ); // process right after left
+                nodeStack.push_back( currNode->left );
+                // Cut else/timeout out of the tree
+                if ( currNode->op == ast::WaitUntilStmt::ClauseNode::LEFT_OR ) {
+                    if ( lastInternalNode )
+                        lastInternalNode->right = currNode->left;
+                    else    // if not set then root is LEFT_OR
+                        retStmt->predicateTree = currNode->left;
+                    currNode->left = nullptr;
+                    cleanup = currNode;
+                }
+                lastInternalNode = currNode;
+                break;
+        }
+    } while ( !nodeStack.empty() );
+    if ( cleanup ) delete cleanup;
+    return retStmt;
+}
+ast::Stmt * build_with( const CodeLocation & location, ExpressionNode * exprs, StatementNode * stmt ) {
+        std::vector<ast::ptr<ast::Expr>> e;
         buildMoveList( exprs, e );
         Statement * s = maybeMoveBuild<Statement>( stmt );
         return new DeclStmt( new WithStmt( e, s ) );
+        ast::Stmt * s = maybeMoveBuild( stmt );
+        return new ast::DeclStmt( location, new ast::WithStmt( location, std::move( e ), s ) );
 } // build_with
 Statement * build_compound( StatementNode * first ) {
         CompoundStmt * cs = new CompoundStmt();
         buildMoveList( first, cs->get_kids() );
+ast::Stmt * build_compound( const CodeLocation & location, StatementNode * first ) {
+        auto cs = new ast::CompoundStmt( location );
+        buildMoveList( first, cs->kids );
         return cs;
 } // build_compound
 …
 // statement and wrap it into a compound statement to insert additional code. Hence, all control structures have a
 // conical form for code generation.
 StatementNode * maybe_build_compound( StatementNode * first ) {
+StatementNode * maybe_build_compound( const CodeLocation & location, StatementNode * first ) {
         // Optimization: if the control-structure statement is a compound statement, do not wrap it.
         // e.g., if (...) {...} do not wrap the existing compound statement.
+        if ( ! dynamic_cast<CompoundStmt *>( first->stmt.get() ) ) { // unique_ptr
+                CompoundStmt * cs = new CompoundStmt();
+                buildMoveList( first, cs->get_kids() );
+                return new StatementNode( cs );
+        if ( !dynamic_cast<ast::CompoundStmt *>( first->stmt.get() ) ) { // unique_ptr
+                return new StatementNode( build_compound( location, first ) );
         } // if
         return first;
 …
 // Question
 Statement * build_asm( bool voltile, Expression * instruction, ExpressionNode * output, ExpressionNode * input, ExpressionNode * clobber, LabelNode * gotolabels ) {
         list< Expression * > out, in;
         list< ConstantExpr * > clob;
+ast::Stmt * build_asm( const CodeLocation & location, bool is_volatile, ExpressionNode * instruction, ExpressionNode * output, ExpressionNode * input, ExpressionNode * clobber, LabelNode * gotolabels ) {
+        std::vector<ast::ptr<ast::Expr>> out, in;
+        std::vector<ast::ptr<ast::ConstantExpr>> clob;
         buildMoveList( output, out );
         buildMoveList( input, in );
         buildMoveList( clobber, clob );
+        return new AsmStmt( voltile, instruction, out, in, clob, gotolabels ? gotolabels->labels : noLabels );
+        return new ast::AsmStmt( location,
+                is_volatile,
+                maybeMoveBuild( instruction ),
+                std::move( out ),
+                std::move( in ),
+                std::move( clob ),
+                gotolabels ? gotolabels->labels : std::vector<ast::Label>()
+        );
 } // build_asm
+Statement * build_directive( string * directive ) {
+        return new DirectiveStmt( *directive );
+ast::Stmt * build_directive( const CodeLocation & location, string * directive ) {
+        auto stmt = new ast::DirectiveStmt( location, *directive );
+        delete directive;
+        return stmt;
 } // build_directive
 Statement * build_mutex( ExpressionNode * exprs, StatementNode * stmt ) {
         list< Expression * > expList;
+ast::Stmt * build_mutex( const CodeLocation & location, ExpressionNode * exprs, StatementNode * stmt ) {
+        std::vector<ast::ptr<ast::Expr>> expList;
         buildMoveList( exprs, expList );
         Statement * body = maybeMoveBuild<Statement>( stmt );
         return new MutexStmt( body, expList );
+        ast::Stmt * body = maybeMoveBuild( stmt );
+        return new ast::MutexStmt( location, body, std::move( expList ) );
 } // build_mutex

src/Parser/TypeData.cc

-              r34b4268
+              r24d6572
 // Author           : Rodolfo G. Esteves
 // Created On       : Sat May 16 15:12:51 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Tue May 10 22:36:52 2022
 // Update Count     : 677
+// Last Modified By : Andrew Beach
+// Last Modified On : Tue Apr  4 13:39:00 2023
+// Update Count     : 680
 //
+#include "TypeData.h"
 #include <cassert>                 // for assert
 #include <ostream>                 // for operator<<, ostream, basic_ostream
+#include "AST/Decl.hpp"            // for AggregateDecl, ObjectDecl, TypeDe...
+#include "AST/Init.hpp"            // for SingleInit, ListInit
+#include "AST/Print.hpp"           // for print
 #include "Common/SemanticError.h"  // for SemanticError
+#include "Common/utility.h"        // for maybeClone, maybeBuild, maybeMoveB...
+#include "Parser/ParseNode.h"      // for DeclarationNode, ExpressionNode
+#include "SynTree/Declaration.h"   // for TypeDecl, ObjectDecl, FunctionDecl
+#include "SynTree/Expression.h"    // for Expression, ConstantExpr (ptr only)
+#include "SynTree/Initializer.h"   // for SingleInit, Initializer (ptr only)
+#include "SynTree/Statement.h"     // for CompoundStmt, Statement
+#include "SynTree/Type.h"          // for BasicType, Type, Type::ForallList
+#include "TypeData.h"
+#include "Common/utility.h"        // for splice, spliceBegin
+#include "Parser/ExpressionNode.h" // for ExpressionNode
+#include "Parser/StatementNode.h"  // for StatementNode
 class Attribute;
 …
 TypeData::TypeData( Kind k ) : location( yylloc ), kind( k ), base( nullptr ), forall( nullptr ) /*, PTR1( (void*)(0xdeadbeefdeadbeef)), PTR2( (void*)(0xdeadbeefdeadbeef) ) */ {
         switch ( kind ) {
+          case Unknown:
+          case Pointer:
+          case Reference:
+          case EnumConstant:
+          case GlobalScope:
+                // nothing else to initialize
+                break;
+          case Basic:
+                // basic = new Basic_t;
+                break;
+          case Array:
+                // array = new Array_t;
+        case Unknown:
+        case Pointer:
+        case Reference:
+        case EnumConstant:
+        case GlobalScope:
+        case Basic:
+                // No unique data to initialize.
+                break;
+        case Array:
                 array.dimension = nullptr;
                 array.isVarLen = false;
                 array.isStatic = false;
                 break;
+          case Function:
+                // function = new Function_t;
+        case Function:
                 function.params = nullptr;
                 function.idList = nullptr;
 …
                 function.withExprs = nullptr;
                 break;
+                // Enum is an Aggregate, so both structures are initialized together.
+          case Enum:
+                // enumeration = new Enumeration_t;
+        case Enum:
                 enumeration.name = nullptr;
                 enumeration.constants = nullptr;
 …
                 enumeration.anon = false;
                 break;
+          case Aggregate:
+                // aggregate = new Aggregate_t;
+                aggregate.kind = AggregateDecl::NoAggregate;
+        case Aggregate:
+                aggregate.kind = ast::AggregateDecl::NoAggregate;
                 aggregate.name = nullptr;
                 aggregate.params = nullptr;
 …
                 aggregate.anon = false;
                 break;
+          case AggregateInst:
+                // aggInst = new AggInst_t;
+        case AggregateInst:
                 aggInst.aggregate = nullptr;
                 aggInst.params = nullptr;
                 aggInst.hoistType = false;
                 break;
+          case Symbolic:
+          case SymbolicInst:
+                // symbolic = new Symbolic_t;
+        case Symbolic:
+        case SymbolicInst:
                 symbolic.name = nullptr;
                 symbolic.params = nullptr;
 …
                 symbolic.assertions = nullptr;
                 break;
+          case Tuple:
+                // tuple = new Tuple_t;
+        case Tuple:
                 tuple = nullptr;
                 break;
+          case Typeof:
+          case Basetypeof:
+                // typeexpr = new Typeof_t;
+        case Typeof:
+        case Basetypeof:
                 typeexpr = nullptr;
                 break;
           case Vtable:
                 break;
           case Builtin:
                 // builtin = new Builtin_t;
                 case Qualified:
+        case Vtable:
+        case Builtin:
+                // No unique data to initialize.
+                break;
+        case Qualified:
                 qualified.parent = nullptr;
                 qualified.child = nullptr;
 …
         switch ( kind ) {
+          case Unknown:
+          case Pointer:
+          case Reference:
+          case EnumConstant:
+          case GlobalScope:
+                // nothing to destroy
+                break;
+          case Basic:
+                // delete basic;
+                break;
+          case Array:
+        case Unknown:
+        case Pointer:
+        case Reference:
+        case EnumConstant:
+        case GlobalScope:
+        case Basic:
+                // No unique data to deconstruct.
+                break;
+        case Array:
                 delete array.dimension;
+                // delete array;
+                break;
+          case Function:
+                break;
+        case Function:
                 delete function.params;
                 delete function.idList;
 …
                 delete function.body;
                 delete function.withExprs;
+                // delete function;
+                break;
+          case Aggregate:
+                break;
+        case Aggregate:
                 delete aggregate.name;
                 delete aggregate.params;
                 delete aggregate.actuals;
                 delete aggregate.fields;
+                // delete aggregate;
+                break;
+          case AggregateInst:
+                break;
+        case AggregateInst:
                 delete aggInst.aggregate;
                 delete aggInst.params;
+                // delete aggInst;
+                break;
+          case Enum:
+                break;
+        case Enum:
                 delete enumeration.name;
                 delete enumeration.constants;
+                // delete enumeration;
+                break;
+          case Symbolic:
+          case SymbolicInst:
+                break;
+        case Symbolic:
+        case SymbolicInst:
                 delete symbolic.name;
                 delete symbolic.params;
                 delete symbolic.actuals;
                 delete symbolic.assertions;
+                // delete symbolic;
+                break;
+          case Tuple:
+                // delete tuple->members;
+                break;
+        case Tuple:
                 delete tuple;
                 break;
+          case Typeof:
+          case Basetypeof:
+                // delete typeexpr->expr;
+        case Typeof:
+        case Basetypeof:
                 delete typeexpr;
                 break;
+          case Vtable:
+                break;
+          case Builtin:
+                // delete builtin;
+                break;
+          case Qualified:
+        case Vtable:
+        case Builtin:
+                // No unique data to deconstruct.
+                break;
+        case Qualified:
                 delete qualified.parent;
                 delete qualified.child;
+                break;
         } // switch
 } // TypeData::~TypeData
 …
         switch ( kind ) {
           case Unknown:
           case EnumConstant:
           case Pointer:
           case Reference:
           case GlobalScope:
+        case Unknown:
+        case EnumConstant:
+        case Pointer:
+        case Reference:
+        case GlobalScope:
                 // nothing else to copy
                 break;
           case Basic:
+        case Basic:
                 newtype->basictype = basictype;
                 newtype->complextype = complextype;
 …
                 newtype->length = length;
                 break;
           case Array:
+        case Array:
                 newtype->array.dimension = maybeClone( array.dimension );
                 newtype->array.isVarLen = array.isVarLen;
                 newtype->array.isStatic = array.isStatic;
                 break;
           case Function:
+        case Function:
                 newtype->function.params = maybeClone( function.params );
                 newtype->function.idList = maybeClone( function.idList );
 …
                 newtype->function.withExprs = maybeClone( function.withExprs );
                 break;
           case Aggregate:
+        case Aggregate:
                 newtype->aggregate.kind = aggregate.kind;
                 newtype->aggregate.name = aggregate.name ? new string( *aggregate.name ) : nullptr;
 …
                 newtype->aggregate.parent = aggregate.parent ? new string( *aggregate.parent ) : nullptr;
                 break;
           case AggregateInst:
+        case AggregateInst:
                 newtype->aggInst.aggregate = maybeClone( aggInst.aggregate );
                 newtype->aggInst.params = maybeClone( aggInst.params );
                 newtype->aggInst.hoistType = aggInst.hoistType;
                 break;
           case Enum:
+        case Enum:
                 newtype->enumeration.name = enumeration.name ? new string( *enumeration.name ) : nullptr;
                 newtype->enumeration.constants = maybeClone( enumeration.constants );
 …
                 newtype->enumeration.anon = enumeration.anon;
                 break;
           case Symbolic:
           case SymbolicInst:
+        case Symbolic:
+        case SymbolicInst:
                 newtype->symbolic.name = symbolic.name ? new string( *symbolic.name ) : nullptr;
                 newtype->symbolic.params = maybeClone( symbolic.params );
 …
                 newtype->symbolic.isTypedef = symbolic.isTypedef;
                 break;
           case Tuple:
+        case Tuple:
                 newtype->tuple = maybeClone( tuple );
                 break;
           case Typeof:
           case Basetypeof:
+        case Typeof:
+        case Basetypeof:
                 newtype->typeexpr = maybeClone( typeexpr );
                 break;
           case Vtable:
                 break;
           case Builtin:
+        case Vtable:
+                break;
+        case Builtin:
                 assert( builtintype == DeclarationNode::Zero || builtintype == DeclarationNode::One );
                 newtype->builtintype = builtintype;
                 break;
                 case Qualified:
+        case Qualified:
                 newtype->qualified.parent = maybeClone( qualified.parent );
                 newtype->qualified.child = maybeClone( qualified.child );
 …
 void TypeData::print( ostream &os, int indent ) const {
+        for ( int i = 0; i < Type::NumTypeQualifier; i += 1 ) {
+                if ( qualifiers[i] ) os << Type::QualifiersNames[ i ] << ' ';
+        } // for
+        ast::print( os, qualifiers );
         if ( forall ) {
 …
         switch ( kind ) {
           case Basic:
+        case Basic:
                 if ( signedness != DeclarationNode::NoSignedness ) os << DeclarationNode::signednessNames[ signedness ] << " ";
                 if ( length != DeclarationNode::NoLength ) os << DeclarationNode::lengthNames[ length ] << " ";
 …
                 if ( basictype != DeclarationNode::NoBasicType ) os << DeclarationNode::basicTypeNames[ basictype ] << " ";
                 break;
           case Pointer:
+        case Pointer:
                 os << "pointer ";
                 if ( base ) {
 …
                 } // if
                 break;
           case Reference:
+        case Reference:
                 os << "reference ";
                 if ( base ) {
 …
                 } // if
                 break;
           case Array:
+        case Array:
                 if ( array.isStatic ) {
                         os << "static ";
 …
                 } // if
                 break;
           case Function:
+        case Function:
                 os << "function" << endl;
                 if ( function.params ) {
 …
                 } // if
                 break;
           case Aggregate:
                 os << AggregateDecl::aggrString( aggregate.kind ) << ' ' << *aggregate.name << endl;
+        case Aggregate:
+                os << ast::AggregateDecl::aggrString( aggregate.kind ) << ' ' << *aggregate.name << endl;
                 if ( aggregate.params ) {
                         os << string( indent + 2, ' ' ) << "with type parameters" << endl;
 …
                 } // if
                 break;
           case AggregateInst:
+        case AggregateInst:
                 if ( aggInst.aggregate ) {
                         os << "instance of " ;
 …
                 } // if
                 break;
           case Enum:
                 os << "enumeration ";
+        case Enum:
+                os << "enumeration " << *enumeration.name << endl;;
                 if ( enumeration.constants ) {
                         os << "with constants" << endl;
 …
                 } // if
                 break;
           case EnumConstant:
+        case EnumConstant:
                 os << "enumeration constant ";
                 break;
           case Symbolic:
+        case Symbolic:
                 if ( symbolic.isTypedef ) {
                         os << "typedef definition ";
 …
                 } // if
                 break;
           case SymbolicInst:
+        case SymbolicInst:
                 os << *symbolic.name;
                 if ( symbolic.actuals ) {
 …
                 } // if
                 break;
           case Tuple:
+        case Tuple:
                 os << "tuple ";
                 if ( tuple ) {
 …
                 } // if
                 break;
           case Basetypeof:
+        case Basetypeof:
                 os << "base-";
                 #if defined(__GNUC__) && __GNUC__ >= 7
 …
                 #endif
                 // FALL THROUGH
           case Typeof:
+        case Typeof:
                 os << "type-of expression ";
                 if ( typeexpr ) {
 …
                 } // if
                 break;
           case Vtable:
+        case Vtable:
                 os << "vtable";
                 break;
           case Builtin:
+        case Builtin:
                 os << DeclarationNode::builtinTypeNames[builtintype];
                 break;
           case GlobalScope:
                 break;
           case Qualified:
+        case GlobalScope:
+                break;
+        case Qualified:
                 qualified.parent->print( os );
                 os << ".";
                 qualified.child->print( os );
                 break;
           case Unknown:
+        case Unknown:
                 os << "entity of unknown type ";
                 break;
           default:
+        default:
                 os << "internal error: TypeData::print " << kind << endl;
                 assert( false );
 …
 const std::string * TypeData::leafName() const {
         switch ( kind ) {
           case Unknown:
           case Pointer:
           case Reference:
           case EnumConstant:
           case GlobalScope:
           case Array:
           case Basic:
           case Function:
           case AggregateInst:
           case Tuple:
           case Typeof:
           case Basetypeof:
           case Builtin:
           case Vtable:
+        case Unknown:
+        case Pointer:
+        case Reference:
+        case EnumConstant:
+        case GlobalScope:
+        case Array:
+        case Basic:
+        case Function:
+        case AggregateInst:
+        case Tuple:
+        case Typeof:
+        case Basetypeof:
+        case Builtin:
+        case Vtable:
                 assertf(false, "Tried to get leaf name from kind without a name: %d", kind);
                 break;
           case Aggregate:
+        case Aggregate:
                 return aggregate.name;
           case Enum:
+        case Enum:
                 return enumeration.name;
           case Symbolic:
           case SymbolicInst:
+        case Symbolic:
+        case SymbolicInst:
                 return symbolic.name;
           case Qualified:
+        case Qualified:
                 return qualified.child->leafName();
         } // switch
 …
+template< typename ForallList >
+void buildForall( const DeclarationNode * firstNode, ForallList &outputList ) {
+        buildList( firstNode, outputList );
+void buildForall(
+                const DeclarationNode * firstNode,
+                std::vector<ast::ptr<ast::TypeInstType>> &outputList ) {
+        {
+                std::vector<ast::ptr<ast::Type>> tmpList;
+                buildTypeList( firstNode, tmpList );
+                for ( auto tmp : tmpList ) {
+                        outputList.emplace_back(
+                                strict_dynamic_cast<const ast::TypeInstType *>(
+                                        tmp.release() ) );
+                }
+        }
         auto n = firstNode;
+        for ( typename ForallList::iterator i = outputList.begin(); i != outputList.end(); ++i, n = (DeclarationNode*)n->get_next() ) {
+                TypeDecl * td = static_cast<TypeDecl *>(*i);
+                if ( n->variable.tyClass == TypeDecl::Otype ) {
+                        // add assertion parameters to `type' tyvars in reverse order
+                        // add dtor:  void ^?{}(T *)
+                        FunctionType * dtorType = new FunctionType( Type::Qualifiers(), false );
+                        dtorType->get_parameters().push_back( new ObjectDecl( "", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, new ReferenceType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), td->get_name(), *i ) ), nullptr ) );
+                        td->get_assertions().push_front( new FunctionDecl( "^?{}", Type::StorageClasses(), LinkageSpec::Cforall, dtorType, nullptr ) );
+                        // add copy ctor:  void ?{}(T *, T)
+                        FunctionType * copyCtorType = new FunctionType( Type::Qualifiers(), false );
+                        copyCtorType->get_parameters().push_back( new ObjectDecl( "", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, new ReferenceType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), td->get_name(), *i ) ), nullptr ) );
+                        copyCtorType->get_parameters().push_back( new ObjectDecl( "", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, new TypeInstType( Type::Qualifiers(), td->get_name(), *i ), nullptr ) );
+                        td->get_assertions().push_front( new FunctionDecl( "?{}", Type::StorageClasses(), LinkageSpec::Cforall, copyCtorType, nullptr ) );
+                        // add default ctor:  void ?{}(T *)
+                        FunctionType * ctorType = new FunctionType( Type::Qualifiers(), false );
+                        ctorType->get_parameters().push_back( new ObjectDecl( "", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, new ReferenceType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), td->get_name(), *i ) ), nullptr ) );
+                        td->get_assertions().push_front( new FunctionDecl( "?{}", Type::StorageClasses(), LinkageSpec::Cforall, ctorType, nullptr ) );
+                        // add assignment operator:  T * ?=?(T *, T)
+                        FunctionType * assignType = new FunctionType( Type::Qualifiers(), false );
+                        assignType->get_parameters().push_back( new ObjectDecl( "", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, new ReferenceType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), td->get_name(), *i ) ), nullptr ) );
+                        assignType->get_parameters().push_back( new ObjectDecl( "", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, new TypeInstType( Type::Qualifiers(), td->get_name(), *i ), nullptr ) );
+                        assignType->get_returnVals().push_back( new ObjectDecl( "", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, new TypeInstType( Type::Qualifiers(), td->get_name(), *i ), nullptr ) );
+                        td->get_assertions().push_front( new FunctionDecl( "?=?", Type::StorageClasses(), LinkageSpec::Cforall, assignType, nullptr ) );
+                } // if
+        for ( auto i = outputList.begin() ;
+                        i != outputList.end() ;
+                        ++i, n = (DeclarationNode*)n->get_next() ) {
+                // Only the object type class adds additional assertions.
+                if ( n->variable.tyClass != ast::TypeDecl::Otype ) {
+                        continue;
+                }
+                ast::TypeDecl const * td = i->strict_as<ast::TypeDecl>();
+                std::vector<ast::ptr<ast::DeclWithType>> newAssertions;
+                auto mutTypeDecl = ast::mutate( td );
+                const CodeLocation & location = mutTypeDecl->location;
+                *i = mutTypeDecl;
+                // add assertion parameters to `type' tyvars in reverse order
+                // add assignment operator:  T * ?=?(T *, T)
+                newAssertions.push_back( new ast::FunctionDecl(
+                        location,
+                        "?=?",
+                        {}, // forall
+                        {}, // assertions
+                        {
+                                new ast::ObjectDecl(
+                                        location,
+                                        "",
+                                        new ast::ReferenceType( i->get() ),
+                                        (ast::Init *)nullptr,
+                                        ast::Storage::Classes(),
+                                        ast::Linkage::Cforall,
+                                        (ast::Expr *)nullptr
+                                ),
+                                new ast::ObjectDecl(
+                                        location,
+                                        "",
+                                        i->get(),
+                                        (ast::Init *)nullptr,
+                                        ast::Storage::Classes(),
+                                        ast::Linkage::Cforall,
+                                        (ast::Expr *)nullptr
+                                ),
+                        }, // params
+                        {
+                                new ast::ObjectDecl(
+                                        location,
+                                        "",
+                                        i->get(),
+                                        (ast::Init *)nullptr,
+                                        ast::Storage::Classes(),
+                                        ast::Linkage::Cforall,
+                                        (ast::Expr *)nullptr
+                                ),
+                        }, // returns
+                        (ast::CompoundStmt *)nullptr,
+                        ast::Storage::Classes(),
+                        ast::Linkage::Cforall
+                ) );
+                // add default ctor:  void ?{}(T *)
+                newAssertions.push_back( new ast::FunctionDecl(
+                        location,
+                        "?{}",
+                        {}, // forall
+                        {}, // assertions
+                        {
+                                new ast::ObjectDecl(
+                                        location,
+                                        "",
+                                        new ast::ReferenceType( i->get() ),
+                                        (ast::Init *)nullptr,
+                                        ast::Storage::Classes(),
+                                        ast::Linkage::Cforall,
+                                        (ast::Expr *)nullptr
+                                ),
+                        }, // params
+                        {}, // returns
+                        (ast::CompoundStmt *)nullptr,
+                        ast::Storage::Classes(),
+                        ast::Linkage::Cforall
+                ) );
+                // add copy ctor:  void ?{}(T *, T)
+                newAssertions.push_back( new ast::FunctionDecl(
+                        location,
+                        "?{}",
+                        {}, // forall
+                        {}, // assertions
+                        {
+                                new ast::ObjectDecl(
+                                        location,
+                                        "",
+                                        new ast::ReferenceType( i->get() ),
+                                        (ast::Init *)nullptr,
+                                        ast::Storage::Classes(),
+                                        ast::Linkage::Cforall,
+                                        (ast::Expr *)nullptr
+                                ),
+                                new ast::ObjectDecl(
+                                        location,
+                                        "",
+                                        i->get(),
+                                        (ast::Init *)nullptr,
+                                        ast::Storage::Classes(),
+                                        ast::Linkage::Cforall,
+                                        (ast::Expr *)nullptr
+                                ),
+                        }, // params
+                        {}, // returns
+                        (ast::CompoundStmt *)nullptr,
+                        ast::Storage::Classes(),
+                        ast::Linkage::Cforall
+                ) );
+                // add dtor:  void ^?{}(T *)
+                newAssertions.push_back( new ast::FunctionDecl(
+                        location,
+                        "^?{}",
+                        {}, // forall
+                        {}, // assertions
+                        {
+                                new ast::ObjectDecl(
+                                        location,
+                                        "",
+                                        new ast::ReferenceType( i->get() ),
+                                        (ast::Init *)nullptr,
+                                        ast::Storage::Classes(),
+                                        ast::Linkage::Cforall,
+                                        (ast::Expr *)nullptr
+                                ),
+                        }, // params
+                        {}, // returns
+                        (ast::CompoundStmt *)nullptr,
+                        ast::Storage::Classes(),
+                        ast::Linkage::Cforall
+                ) );
+                spliceBegin( mutTypeDecl->assertions, newAssertions );
+        } // for
+}
+void buildForall(
+                const DeclarationNode * firstNode,
+                std::vector<ast::ptr<ast::TypeDecl>> &outputForall ) {
+        buildList( firstNode, outputForall );
+        auto n = firstNode;
+        for ( auto i = outputForall.begin() ;
+                        i != outputForall.end() ;
+                        ++i, n = (DeclarationNode*)n->get_next() ) {
+                // Only the object type class adds additional assertions.
+                if ( n->variable.tyClass != ast::TypeDecl::Otype ) {
+                        continue;
+                }
+                ast::TypeDecl const * td = i->strict_as<ast::TypeDecl>();
+                std::vector<ast::ptr<ast::DeclWithType>> newAssertions;
+                auto mutTypeDecl = ast::mutate( td );
+                const CodeLocation & location = mutTypeDecl->location;
+                *i = mutTypeDecl;
+                // add assertion parameters to `type' tyvars in reverse order
+                // add assignment operator:  T * ?=?(T *, T)
+                newAssertions.push_back( new ast::FunctionDecl(
+                        location,
+                        "?=?",
+                        {}, // forall
+                        {}, // assertions
+                        {
+                                new ast::ObjectDecl(
+                                        location,
+                                        "",
+                                        new ast::ReferenceType( new ast::TypeInstType( td->name, *i ) ),
+                                        (ast::Init *)nullptr,
+                                        ast::Storage::Classes(),
+                                        ast::Linkage::Cforall,
+                                        (ast::Expr *)nullptr
+                                ),
+                                new ast::ObjectDecl(
+                                        location,
+                                        "",
+                                        new ast::TypeInstType( td->name, *i ),
+                                        (ast::Init *)nullptr,
+                                        ast::Storage::Classes(),
+                                        ast::Linkage::Cforall,
+                                        (ast::Expr *)nullptr
+                                ),
+                        }, // params
+                        {
+                                new ast::ObjectDecl(
+                                        location,
+                                        "",
+                                        new ast::TypeInstType( td->name, *i ),
+                                        (ast::Init *)nullptr,
+                                        ast::Storage::Classes(),
+                                        ast::Linkage::Cforall,
+                                        (ast::Expr *)nullptr
+                                ),
+                        }, // returns
+                        (ast::CompoundStmt *)nullptr,
+                        ast::Storage::Classes(),
+                        ast::Linkage::Cforall
+                ) );
+                // add default ctor:  void ?{}(T *)
+                newAssertions.push_back( new ast::FunctionDecl(
+                        location,
+                        "?{}",
+                        {}, // forall
+                        {}, // assertions
+                        {
+                                new ast::ObjectDecl(
+                                        location,
+                                        "",
+                                        new ast::ReferenceType(
+                                                new ast::TypeInstType( td->name, i->get() ) ),
+                                        (ast::Init *)nullptr,
+                                        ast::Storage::Classes(),
+                                        ast::Linkage::Cforall,
+                                        (ast::Expr *)nullptr
+                                ),
+                        }, // params
+                        {}, // returns
+                        (ast::CompoundStmt *)nullptr,
+                        ast::Storage::Classes(),
+                        ast::Linkage::Cforall
+                ) );
+                // add copy ctor:  void ?{}(T *, T)
+                newAssertions.push_back( new ast::FunctionDecl(
+                        location,
+                        "?{}",
+                        {}, // forall
+                        {}, // assertions
+                        {
+                                new ast::ObjectDecl(
+                                        location,
+                                        "",
+                                        new ast::ReferenceType(
+                                                new ast::TypeInstType( td->name, *i ) ),
+                                        (ast::Init *)nullptr,
+                                        ast::Storage::Classes(),
+                                        ast::Linkage::Cforall,
+                                        (ast::Expr *)nullptr
+                                ),
+                                new ast::ObjectDecl(
+                                        location,
+                                        "",
+                                        new ast::TypeInstType( td->name, *i ),
+                                        (ast::Init *)nullptr,
+                                        ast::Storage::Classes(),
+                                        ast::Linkage::Cforall,
+                                        (ast::Expr *)nullptr
+                                ),
+                        }, // params
+                        {}, // returns
+                        (ast::CompoundStmt *)nullptr,
+                        ast::Storage::Classes(),
+                        ast::Linkage::Cforall
+                ) );
+                // add dtor:  void ^?{}(T *)
+                newAssertions.push_back( new ast::FunctionDecl(
+                        location,
+                        "^?{}",
+                        {}, // forall
+                        {}, // assertions
+                        {
+                                new ast::ObjectDecl(
+                                        location,
+                                        "",
+                                        new ast::ReferenceType(
+                                                new ast::TypeInstType( i->get() )
+                                        ),
+                                        (ast::Init *)nullptr,
+                                        ast::Storage::Classes(),
+                                        ast::Linkage::Cforall,
+                                        (ast::Expr *)nullptr
+                                ),
+                        }, // params
+                        {}, // returns
+                        (ast::CompoundStmt *)nullptr,
+                        ast::Storage::Classes(),
+                        ast::Linkage::Cforall
+                ) );
+                spliceBegin( mutTypeDecl->assertions, newAssertions );
         } // for
 } // buildForall
 Type * typebuild( const TypeData * td ) {
+ast::Type * typebuild( const TypeData * td ) {
         assert( td );
         switch ( td->kind ) {
           case TypeData::Unknown:
+        case TypeData::Unknown:
                 // fill in implicit int
+                return new BasicType( buildQualifiers( td ), BasicType::SignedInt );
+          case TypeData::Basic:
+                return new ast::BasicType(
+                        ast::BasicType::SignedInt,
+                        buildQualifiers( td )
+                );
+        case TypeData::Basic:
                 return buildBasicType( td );
           case TypeData::Pointer:
+        case TypeData::Pointer:
                 return buildPointer( td );
           case TypeData::Array:
+        case TypeData::Array:
                 return buildArray( td );
           case TypeData::Reference:
+        case TypeData::Reference:
                 return buildReference( td );
           case TypeData::Function:
                 return buildFunction( td );
           case TypeData::AggregateInst:
+        case TypeData::Function:
+                return buildFunctionType( td );
+        case TypeData::AggregateInst:
                 return buildAggInst( td );
           case TypeData::EnumConstant:
                 return new EnumInstType( buildQualifiers( td ), "" );
           case TypeData::SymbolicInst:
+        case TypeData::EnumConstant:
+                return new ast::EnumInstType( "", buildQualifiers( td ) );
+        case TypeData::SymbolicInst:
                 return buildSymbolicInst( td );
           case TypeData::Tuple:
+        case TypeData::Tuple:
                 return buildTuple( td );
           case TypeData::Typeof:
           case TypeData::Basetypeof:
+        case TypeData::Typeof:
+        case TypeData::Basetypeof:
                 return buildTypeof( td );
           case TypeData::Vtable:
+        case TypeData::Vtable:
                 return buildVtable( td );
           case TypeData::Builtin:
+        case TypeData::Builtin:
                 switch ( td->builtintype ) {
                   case DeclarationNode::Zero:
                         return new ZeroType( noQualifiers );
                   case DeclarationNode::One:
                         return new OneType( noQualifiers );
                   default:
                         return new VarArgsType( buildQualifiers( td ) );
+                case DeclarationNode::Zero:
+                        return new ast::ZeroType();
+                case DeclarationNode::One:
+                        return new ast::OneType();
+                default:
+                        return new ast::VarArgsType( buildQualifiers( td ) );
                 } // switch
+          case TypeData::GlobalScope:
+                return new GlobalScopeType();
+          case TypeData::Qualified:
+                return new QualifiedType( buildQualifiers( td ), typebuild( td->qualified.parent ), typebuild( td->qualified.child ) );
+          case TypeData::Symbolic:
+          case TypeData::Enum:
+          case TypeData::Aggregate:
+        case TypeData::GlobalScope:
+                return new ast::GlobalScopeType();
+        case TypeData::Qualified:
+                return new ast::QualifiedType(
+                        typebuild( td->qualified.parent ),
+                        typebuild( td->qualified.child ),
+                        buildQualifiers( td )
+                );
+        case TypeData::Symbolic:
+        case TypeData::Enum:
+        case TypeData::Aggregate:
                 assert( false );
         } // switch
 …
         switch ( td->kind ) {
           case TypeData::Aggregate:
+        case TypeData::Aggregate:
                 if ( ! toplevel && td->aggregate.body ) {
                         ret = td->clone();
                 } // if
                 break;
           case TypeData::Enum:
+        case TypeData::Enum:
                 if ( ! toplevel && td->enumeration.body ) {
                         ret = td->clone();
                 } // if
                 break;
           case TypeData::AggregateInst:
+        case TypeData::AggregateInst:
                 if ( td->aggInst.aggregate ) {
                         ret = typeextractAggregate( td->aggInst.aggregate, false );
                 } // if
                 break;
           default:
+        default:
                 if ( td->base ) {
                         ret = typeextractAggregate( td->base, false );
 …
 Type::Qualifiers buildQualifiers( const TypeData * td ) {
+ast::CV::Qualifiers buildQualifiers( const TypeData * td ) {
         return td->qualifiers;
 } // buildQualifiers
 …
 } // genTSError
 Type * buildBasicType( const TypeData * td ) {
         BasicType::Kind ret;
+ast::Type * buildBasicType( const TypeData * td ) {
+        ast::BasicType::Kind ret;
         switch ( td->basictype ) {
           case DeclarationNode::Void:
+        case DeclarationNode::Void:
                 if ( td->signedness != DeclarationNode::NoSignedness ) {
                         genTSError( DeclarationNode::signednessNames[ td->signedness ], td->basictype );
 …
                         genTSError( DeclarationNode::lengthNames[ td->length ], td->basictype );
                 } // if
                 return new VoidType( buildQualifiers( td ) );
                 break;
           case DeclarationNode::Bool:
+                return new ast::VoidType( buildQualifiers( td ) );
+                break;
+        case DeclarationNode::Bool:
                 if ( td->signedness != DeclarationNode::NoSignedness ) {
                         genTSError( DeclarationNode::signednessNames[ td->signedness ], td->basictype );
 …
                 } // if
                 ret = BasicType::Bool;
                 break;
           case DeclarationNode::Char:
+                ret = ast::BasicType::Bool;
+                break;
+        case DeclarationNode::Char:
                 // C11 Standard 6.2.5.15: The three types char, signed char, and unsigned char are collectively called the
                 // character types. The implementation shall define char to have the same range, representation, and behavior as
                 // either signed char or unsigned char.
                 static BasicType::Kind chartype[] = { BasicType::SignedChar, BasicType::UnsignedChar, BasicType::Char };
+                static ast::BasicType::Kind chartype[] = { ast::BasicType::SignedChar, ast::BasicType::UnsignedChar, ast::BasicType::Char };
                 if ( td->length != DeclarationNode::NoLength ) {
 …
                 break;
           case DeclarationNode::Int:
                 static BasicType::Kind inttype[2][4] = {
                         { BasicType::ShortSignedInt, BasicType::LongSignedInt, BasicType::LongLongSignedInt, BasicType::SignedInt },
                         { BasicType::ShortUnsignedInt, BasicType::LongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::UnsignedInt },
+        case DeclarationNode::Int:
+                static ast::BasicType::Kind inttype[2][4] = {
+                        { ast::BasicType::ShortSignedInt, ast::BasicType::LongSignedInt, ast::BasicType::LongLongSignedInt, ast::BasicType::SignedInt },
+                        { ast::BasicType::ShortUnsignedInt, ast::BasicType::LongUnsignedInt, ast::BasicType::LongLongUnsignedInt, ast::BasicType::UnsignedInt },
                 };
           Integral: ;
+        Integral: ;
                 if ( td->signedness == DeclarationNode::NoSignedness ) {
                         const_cast<TypeData *>(td)->signedness = DeclarationNode::Signed;
 …
                 break;
           case DeclarationNode::Int128:
                 ret = td->signedness == DeclarationNode::Unsigned ? BasicType::UnsignedInt128 : BasicType::SignedInt128;
+        case DeclarationNode::Int128:
+                ret = td->signedness == DeclarationNode::Unsigned ? ast::BasicType::UnsignedInt128 : ast::BasicType::SignedInt128;
                 if ( td->length != DeclarationNode::NoLength ) {
                         genTSError( DeclarationNode::lengthNames[ td->length ], td->basictype );
 …
                 break;
           case DeclarationNode::Float:
           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, },
+        case DeclarationNode::Float:
+        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 ast::BasicType::Kind floattype[2][12] = {
+                        { ast::BasicType::FloatComplex, ast::BasicType::DoubleComplex, ast::BasicType::LongDoubleComplex, (ast::BasicType::Kind)-1, (ast::BasicType::Kind)-1, ast::BasicType::uFloat16Complex, ast::BasicType::uFloat32Complex, ast::BasicType::uFloat32xComplex, ast::BasicType::uFloat64Complex, ast::BasicType::uFloat64xComplex, ast::BasicType::uFloat128Complex, ast::BasicType::uFloat128xComplex, },
+                        { ast::BasicType::Float, ast::BasicType::Double, ast::BasicType::LongDouble, ast::BasicType::uuFloat80, ast::BasicType::uuFloat128, ast::BasicType::uFloat16, ast::BasicType::uFloat32, ast::BasicType::uFloat32x, ast::BasicType::uFloat64, ast::BasicType::uFloat64x, ast::BasicType::uFloat128, ast::BasicType::uFloat128x, },
                 };
           FloatingPoint: ;
+        FloatingPoint: ;
                 if ( td->signedness != DeclarationNode::NoSignedness ) {
                         genTSError( DeclarationNode::signednessNames[ td->signedness ], td->basictype );
 …
                 break;
           case DeclarationNode::NoBasicType:
+        case DeclarationNode::NoBasicType:
                 // No basic type in declaration => default double for Complex/Imaginary and int type for integral types
                 if ( td->complextype == DeclarationNode::Complex || td->complextype == DeclarationNode::Imaginary ) {
 …
                 const_cast<TypeData *>(td)->basictype = DeclarationNode::Int;
                 goto Integral;
           default:
                 assertf( false, "unknown basic type" );
+        default:
+                assertf( false, "unknown basic type" );
                 return nullptr;
         } // switch
+        BasicType * bt = new BasicType( buildQualifiers( td ), ret );
+        buildForall( td->forall, bt->get_forall() );
+        ast::BasicType * bt = new ast::BasicType( ret, buildQualifiers( td ) );
         return bt;
 } // buildBasicType
 PointerType * buildPointer( const TypeData * td ) {
         PointerType * pt;
+ast::PointerType * buildPointer( const TypeData * td ) {
+        ast::PointerType * pt;
         if ( td->base ) {
+                pt = new PointerType( buildQualifiers( td ), typebuild( td->base ) );
+                pt = new ast::PointerType(
+                        typebuild( td->base ),
+                        buildQualifiers( td )
+                );
         } else {
+                pt = new PointerType( buildQualifiers( td ), new BasicType( Type::Qualifiers(), BasicType::SignedInt ) );
+                pt = new ast::PointerType(
+                        new ast::BasicType( ast::BasicType::SignedInt ),
+                        buildQualifiers( td )
+                );
         } // if
-        buildForall( td->forall, pt->get_forall() );
         return pt;
 } // buildPointer
 ArrayType * buildArray( const TypeData * td ) {
         ArrayType * at;
+ast::ArrayType * buildArray( const TypeData * td ) {
+        ast::ArrayType * at;
         if ( td->base ) {
+                at = new ArrayType( buildQualifiers( td ), typebuild( td->base ), maybeBuild< Expression >( td->array.dimension ),
+                                                        td->array.isVarLen, td->array.isStatic );
+                at = new ast::ArrayType(
+                        typebuild( td->base ),
+                        maybeBuild( td->array.dimension ),
+                        td->array.isVarLen ? ast::VariableLen : ast::FixedLen,
+                        td->array.isStatic ? ast::StaticDim : ast::DynamicDim,
+                        buildQualifiers( td )
+                );
         } else {
+                at = new ArrayType( buildQualifiers( td ), new BasicType( Type::Qualifiers(), BasicType::SignedInt ),
+                                                        maybeBuild< Expression >( td->array.dimension ), td->array.isVarLen, td->array.isStatic );
+                at = new ast::ArrayType(
+                        new ast::BasicType( ast::BasicType::SignedInt ),
+                        maybeBuild( td->array.dimension ),
+                        td->array.isVarLen ? ast::VariableLen : ast::FixedLen,
+                        td->array.isStatic ? ast::StaticDim : ast::DynamicDim,
+                        buildQualifiers( td )
+                );
         } // if
-        buildForall( td->forall, at->get_forall() );
         return at;
 } // buildArray
 ReferenceType * buildReference( const TypeData * td ) {
         ReferenceType * rt;
+ast::ReferenceType * buildReference( const TypeData * td ) {
+        ast::ReferenceType * rt;
         if ( td->base ) {
+                rt = new ReferenceType( buildQualifiers( td ), typebuild( td->base ) );
+                rt = new ast::ReferenceType(
+                        typebuild( td->base ),
+                        buildQualifiers( td )
+                );
         } else {
+                rt = new ReferenceType( buildQualifiers( td ), new BasicType( Type::Qualifiers(), BasicType::SignedInt ) );
+                rt = new ast::ReferenceType(
+                        new ast::BasicType( ast::BasicType::SignedInt ),
+                        buildQualifiers( td )
+                );
         } // if
-        buildForall( td->forall, rt->get_forall() );
         return rt;
 } // buildReference
 AggregateDecl * buildAggregate( const TypeData * td, std::list< Attribute * > attributes, LinkageSpec::Spec linkage ) {
+ast::AggregateDecl * buildAggregate( const TypeData * td, std::vector<ast::ptr<ast::Attribute>> attributes, ast::Linkage::Spec linkage ) {
         assert( td->kind == TypeData::Aggregate );
         AggregateDecl * at;
+        ast::AggregateDecl * at;
         switch ( td->aggregate.kind ) {
+          case AggregateDecl::Struct:
+          case AggregateDecl::Coroutine:
+          case AggregateDecl::Exception:
+          case AggregateDecl::Generator:
+          case AggregateDecl::Monitor:
+          case AggregateDecl::Thread:
+                at = new StructDecl( *td->aggregate.name, td->aggregate.kind, attributes, linkage );
+                buildForall( td->aggregate.params, at->get_parameters() );
+                break;
+          case AggregateDecl::Union:
+                at = new UnionDecl( *td->aggregate.name, attributes, linkage );
+                buildForall( td->aggregate.params, at->get_parameters() );
+                break;
+          case AggregateDecl::Trait:
+                at = new TraitDecl( *td->aggregate.name, attributes, linkage );
+                buildList( td->aggregate.params, at->get_parameters() );
+                break;
+          default:
+        case ast::AggregateDecl::Struct:
+        case ast::AggregateDecl::Coroutine:
+        case ast::AggregateDecl::Exception:
+        case ast::AggregateDecl::Generator:
+        case ast::AggregateDecl::Monitor:
+        case ast::AggregateDecl::Thread:
+                at = new ast::StructDecl( td->location,
+                        *td->aggregate.name,
+                        td->aggregate.kind,
+                        std::move( attributes ),
+                        linkage
+                );
+                buildForall( td->aggregate.params, at->params );
+                break;
+        case ast::AggregateDecl::Union:
+                at = new ast::UnionDecl( td->location,
+                        *td->aggregate.name,
+                        std::move( attributes ),
+                        linkage
+                );
+                buildForall( td->aggregate.params, at->params );
+                break;
+        case ast::AggregateDecl::Trait:
+                at = new ast::TraitDecl( td->location,
+                        *td->aggregate.name,
+                        std::move( attributes ),
+                        linkage
+                );
+                buildList( td->aggregate.params, at->params );
+                break;
+        default:
                 assert( false );
         } // switch
         buildList( td->aggregate.fields, at->get_members() );
+        buildList( td->aggregate.fields, at->members );
         at->set_body( td->aggregate.body );
 …
+ReferenceToType * buildComAggInst( const TypeData * type, std::list< Attribute * > attributes, LinkageSpec::Spec linkage ) {
+ast::BaseInstType * buildComAggInst(
+                const TypeData * type,
+                std::vector<ast::ptr<ast::Attribute>> && attributes,
+                ast::Linkage::Spec linkage ) {
         switch ( type->kind ) {
+          case TypeData::Enum: {
+                  if ( type->enumeration.body ) {
+                          EnumDecl * typedecl = buildEnum( type, attributes, linkage );
+                          return new EnumInstType( buildQualifiers( type ), typedecl );
+                  } else {
+                          return new EnumInstType( buildQualifiers( type ), *type->enumeration.name );
+                  } // if
+          }
+          case TypeData::Aggregate: {
+                  ReferenceToType * ret;
+                  if ( type->aggregate.body ) {
+                          AggregateDecl * typedecl = buildAggregate( type, attributes, linkage );
+                          switch ( type->aggregate.kind ) {
+                                case AggregateDecl::Struct:
+                                case AggregateDecl::Coroutine:
+                                case AggregateDecl::Monitor:
+                                case AggregateDecl::Thread:
+                                  ret = new StructInstType( buildQualifiers( type ), (StructDecl *)typedecl );
+                                  break;
+                                case AggregateDecl::Union:
+                                  ret = new UnionInstType( buildQualifiers( type ), (UnionDecl *)typedecl );
+                                  break;
+                                case AggregateDecl::Trait:
+                                  assert( false );
+                                  //ret = new TraitInstType( buildQualifiers( type ), (TraitDecl *)typedecl );
+                                  break;
+                                default:
+                                  assert( false );
+                          } // switch
+                  } else {
+                          switch ( type->aggregate.kind ) {
+                                case AggregateDecl::Struct:
+                                case AggregateDecl::Coroutine:
+                                case AggregateDecl::Monitor:
+                                case AggregateDecl::Thread:
+                                  ret = new StructInstType( buildQualifiers( type ), *type->aggregate.name );
+                                  break;
+                                case AggregateDecl::Union:
+                                  ret = new UnionInstType( buildQualifiers( type ), *type->aggregate.name );
+                                  break;
+                                case AggregateDecl::Trait:
+                                  ret = new TraitInstType( buildQualifiers( type ), *type->aggregate.name );
+                                  break;
+                                default:
+                                  assert( false );
+                          } // switch
+                  } // if
+                  return ret;
+          }
+          default:
+        case TypeData::Enum:
+                if ( type->enumeration.body ) {
+                        ast::EnumDecl * typedecl =
+                                buildEnum( type, std::move( attributes ), linkage );
+                        return new ast::EnumInstType(
+                                typedecl,
+                                buildQualifiers( type )
+                        );
+                } else {
+                        return new ast::EnumInstType(
+                                *type->enumeration.name,
+                                buildQualifiers( type )
+                        );
+                } // if
+                break;
+        case TypeData::Aggregate:
+                if ( type->aggregate.body ) {
+                        ast::AggregateDecl * typedecl =
+                                buildAggregate( type, std::move( attributes ), linkage );
+                        switch ( type->aggregate.kind ) {
+                        case ast::AggregateDecl::Struct:
+                        case ast::AggregateDecl::Coroutine:
+                        case ast::AggregateDecl::Monitor:
+                        case ast::AggregateDecl::Thread:
+                                return new ast::StructInstType(
+                                        strict_dynamic_cast<ast::StructDecl *>( typedecl ),
+                                        buildQualifiers( type )
+                                );
+                        case ast::AggregateDecl::Union:
+                                return new ast::UnionInstType(
+                                        strict_dynamic_cast<ast::UnionDecl *>( typedecl ),
+                                        buildQualifiers( type )
+                                );
+                        case ast::AggregateDecl::Trait:
+                                assert( false );
+                                break;
+                        default:
+                                assert( false );
+                        } // switch
+                } else {
+                        switch ( type->aggregate.kind ) {
+                        case ast::AggregateDecl::Struct:
+                        case ast::AggregateDecl::Coroutine:
+                        case ast::AggregateDecl::Monitor:
+                        case ast::AggregateDecl::Thread:
+                                return new ast::StructInstType(
+                                        *type->aggregate.name,
+                                        buildQualifiers( type )
+                                );
+                        case ast::AggregateDecl::Union:
+                                return new ast::UnionInstType(
+                                        *type->aggregate.name,
+                                        buildQualifiers( type )
+                                );
+                        case ast::AggregateDecl::Trait:
+                                return new ast::TraitInstType(
+                                        *type->aggregate.name,
+                                        buildQualifiers( type )
+                                );
+                        default:
+                                assert( false );
+                        } // switch
+                        break;
+                } // if
+                break;
+        default:
                 assert( false );
         } // switch
+        assert( false );
 } // buildAggInst
 ReferenceToType * buildAggInst( const TypeData * td ) {
+ast::BaseInstType * buildAggInst( const TypeData * td ) {
         assert( td->kind == TypeData::AggregateInst );
+        // ReferenceToType * ret = buildComAggInst( td->aggInst.aggregate, std::list< Attribute * >() );
+        ReferenceToType * ret = nullptr;
+        ast::BaseInstType * ret = nullptr;
         TypeData * type = td->aggInst.aggregate;
         switch ( type->kind ) {
+          case TypeData::Enum: {
+                  return new EnumInstType( buildQualifiers( type ), *type->enumeration.name );
+          }
+          case TypeData::Aggregate: {
+                  switch ( type->aggregate.kind ) {
+                        case AggregateDecl::Struct:
+                        case AggregateDecl::Coroutine:
+                        case AggregateDecl::Monitor:
+                        case AggregateDecl::Thread:
+                          ret = new StructInstType( buildQualifiers( type ), *type->aggregate.name );
+                          break;
+                        case AggregateDecl::Union:
+                          ret = new UnionInstType( buildQualifiers( type ), *type->aggregate.name );
+                          break;
+                        case AggregateDecl::Trait:
+                          ret = new TraitInstType( buildQualifiers( type ), *type->aggregate.name );
+                          break;
+                        default:
+                          assert( false );
+                  } // switch
+          }
+          break;
+          default:
+        case TypeData::Enum:
+                return new ast::EnumInstType(
+                        *type->enumeration.name,
+                        buildQualifiers( type )
+                );
+        case TypeData::Aggregate:
+                switch ( type->aggregate.kind ) {
+                case ast::AggregateDecl::Struct:
+                case ast::AggregateDecl::Coroutine:
+                case ast::AggregateDecl::Monitor:
+                case ast::AggregateDecl::Thread:
+                        ret = new ast::StructInstType(
+                                *type->aggregate.name,
+                                buildQualifiers( type )
+                        );
+                        break;
+                case ast::AggregateDecl::Union:
+                        ret = new ast::UnionInstType(
+                                *type->aggregate.name,
+                                buildQualifiers( type )
+                        );
+                        break;
+                case ast::AggregateDecl::Trait:
+                        ret = new ast::TraitInstType(
+                                *type->aggregate.name,
+                                buildQualifiers( type )
+                        );
+                        break;
+                default:
+                        assert( false );
+                } // switch
+                break;
+        default:
                 assert( false );
         } // switch
+        ret->set_hoistType( td->aggInst.hoistType );
+        buildList( td->aggInst.params, ret->get_parameters() );
+        buildForall( td->forall, ret->get_forall() );
+        ret->hoistType = td->aggInst.hoistType;
+        buildList( td->aggInst.params, ret->params );
         return ret;
 } // buildAggInst
+NamedTypeDecl * buildSymbolic( const TypeData * td, std::list< Attribute * > attributes, const string & name, Type::StorageClasses scs, LinkageSpec::Spec linkage ) {
+ast::NamedTypeDecl * buildSymbolic(
+                const TypeData * td,
+                std::vector<ast::ptr<ast::Attribute>> attributes,
+                const std::string & name,
+                ast::Storage::Classes scs,
+                ast::Linkage::Spec linkage ) {
         assert( td->kind == TypeData::Symbolic );
         NamedTypeDecl * ret;
+        ast::NamedTypeDecl * ret;
         assert( td->base );
         if ( td->symbolic.isTypedef ) {
+                ret = new TypedefDecl( name, td->location, scs, typebuild( td->base ), linkage );
+                ret = new ast::TypedefDecl(
+                        td->location,
+                        name,
+                        scs,
+                        typebuild( td->base ),
+                        linkage
+                );
         } else {
+                ret = new TypeDecl( name, scs, typebuild( td->base ), TypeDecl::Dtype, true );
+                ret = new ast::TypeDecl(
+                        td->location,
+                        name,
+                        scs,
+                        typebuild( td->base ),
+                        ast::TypeDecl::Dtype,
+                        true
+                );
         } // if
         buildList( td->symbolic.assertions, ret->get_assertions() );
         ret->base->attributes.splice( ret->base->attributes.end(), attributes );
+        buildList( td->symbolic.assertions, ret->assertions );
+        splice( ret->base.get_and_mutate()->attributes, attributes );
         return ret;
 } // buildSymbolic
+EnumDecl * buildEnum( const TypeData * td, std::list< Attribute * > attributes, LinkageSpec::Spec linkage ) {
+ast::EnumDecl * buildEnum(
+                const TypeData * td,
+                std::vector<ast::ptr<ast::Attribute>> && attributes,
+                ast::Linkage::Spec linkage ) {
         assert( td->kind == TypeData::Enum );
+        Type * baseType = td->base ? typebuild(td->base) : nullptr;
+        EnumDecl * ret = new EnumDecl( *td->enumeration.name, attributes, td->enumeration.typed, linkage, baseType );
+        buildList( td->enumeration.constants, ret->get_members() );
+        list< Declaration * >::iterator members = ret->get_members().begin();
+        ret->hide = td->enumeration.hiding == EnumHiding::Hide ? EnumDecl::EnumHiding::Hide : EnumDecl::EnumHiding::Visible;
+        ast::Type * baseType = td->base ? typebuild(td->base) : nullptr;
+        ast::EnumDecl * ret = new ast::EnumDecl(
+                td->location,
+                *td->enumeration.name,
+                td->enumeration.typed,
+                std::move( attributes ),
+                linkage,
+                baseType
+        );
+        buildList( td->enumeration.constants, ret->members );
+        auto members = ret->members.begin();
+        ret->hide = td->enumeration.hiding == EnumHiding::Hide ? ast::EnumDecl::EnumHiding::Hide : ast::EnumDecl::EnumHiding::Visible;
         for ( const DeclarationNode * cur = td->enumeration.constants; cur != nullptr; cur = dynamic_cast< DeclarationNode * >( cur->get_next() ), ++members ) {
                 if ( cur->enumInLine ) {
 …
                         SemanticError( td->location, "Enumerator of enum(void) cannot have an explicit initializer value." );
                 } else if ( cur->has_enumeratorValue() ) {
+                        ObjectDecl * member = dynamic_cast< ObjectDecl * >(* members);
+                        member->set_init( new SingleInit( maybeMoveBuild< Expression >( cur->consume_enumeratorValue() ) ) );
+                        ast::Decl * member = members->get_and_mutate();
+                        ast::ObjectDecl * object = strict_dynamic_cast<ast::ObjectDecl *>( member );
+                        object->init = new ast::SingleInit(
+                                td->location,
+                                maybeMoveBuild( cur->consume_enumeratorValue() ),
+                                ast::NoConstruct
+                        );
                 } else if ( !cur->initializer ) {
                         if ( baseType && (!dynamic_cast<BasicType *>(baseType) || !dynamic_cast<BasicType *>(baseType)->isWholeNumber())) {
+                        if ( baseType && (!dynamic_cast<ast::BasicType *>(baseType) || !dynamic_cast<ast::BasicType *>(baseType)->isInteger())) {
                                 SemanticError( td->location, "Enumerators of an non-integer typed enum must be explicitly initialized." );
+                        }
 …
                 // if
         } // for
         ret->set_body( td->enumeration.body );
+        ret->body = td->enumeration.body;
         return ret;
 } // buildEnum
 TypeInstType * buildSymbolicInst( const TypeData * td ) {
+ast::TypeInstType * buildSymbolicInst( const TypeData * td ) {
         assert( td->kind == TypeData::SymbolicInst );
+        TypeInstType * ret = new TypeInstType( buildQualifiers( td ), *td->symbolic.name, false );
+        buildList( td->symbolic.actuals, ret->get_parameters() );
+        buildForall( td->forall, ret->get_forall() );
+        ast::TypeInstType * ret = new ast::TypeInstType(
+                *td->symbolic.name,
+                ast::TypeDecl::Dtype,
+                buildQualifiers( td )
+        );
+        buildList( td->symbolic.actuals, ret->params );
         return ret;
 } // buildSymbolicInst
 TupleType * buildTuple( const TypeData * td ) {
+ast::TupleType * buildTuple( const TypeData * td ) {
         assert( td->kind == TypeData::Tuple );
         std::list< Type * > types;
+        std::vector<ast::ptr<ast::Type>> types;
         buildTypeList( td->tuple, types );
+        TupleType * ret = new TupleType( buildQualifiers( td ), types );
+        buildForall( td->forall, ret->get_forall() );
+        ast::TupleType * ret = new ast::TupleType(
+                std::move( types ),
+                buildQualifiers( td )
+        );
         return ret;
 } // buildTuple
 TypeofType * buildTypeof( const TypeData * td ) {
+ast::TypeofType * buildTypeof( const TypeData * td ) {
         assert( td->kind == TypeData::Typeof || td->kind == TypeData::Basetypeof );
         assert( td->typeexpr );
+        // assert( td->typeexpr->expr );
+        return new TypeofType{ buildQualifiers( td ), td->typeexpr->build(), td->kind == TypeData::Basetypeof };
+        return new ast::TypeofType(
+                td->typeexpr->build(),
+                td->kind == TypeData::Typeof
+                        ? ast::TypeofType::Typeof : ast::TypeofType::Basetypeof,
+                buildQualifiers( td )
+        );
 } // buildTypeof
 VTableType * buildVtable( const TypeData * td ) {
+ast::VTableType * buildVtable( const TypeData * td ) {
         assert( td->base );
+        return new VTableType{ buildQualifiers( td ), typebuild( td->base ) };
+        return new ast::VTableType(
+                typebuild( td->base ),
+                buildQualifiers( td )
+        );
 } // buildVtable
+Declaration * buildDecl( const TypeData * td, const string &name, Type::StorageClasses scs, Expression * bitfieldWidth, Type::FuncSpecifiers funcSpec, LinkageSpec::Spec linkage, Expression *asmName, Initializer * init, std::list< Attribute * > attributes ) {
+ast::FunctionDecl * buildFunctionDecl(
+                const TypeData * td,
+                const string &name,
+                ast::Storage::Classes scs,
+                ast::Function::Specs funcSpec,
+                ast::Linkage::Spec linkage,
+                ast::Expr * asmName,
+                std::vector<ast::ptr<ast::Attribute>> && attributes ) {
+        assert( td->kind == TypeData::Function );
+        // For some reason FunctionDecl takes a bool instead of an ArgumentFlag.
+        bool isVarArgs = !td->function.params || td->function.params->hasEllipsis;
+        ast::CV::Qualifiers cvq = buildQualifiers( td );
+        std::vector<ast::ptr<ast::TypeDecl>> forall;
+        std::vector<ast::ptr<ast::DeclWithType>> assertions;
+        std::vector<ast::ptr<ast::DeclWithType>> params;
+        std::vector<ast::ptr<ast::DeclWithType>> returns;
+        buildList( td->function.params, params );
+        buildForall( td->forall, forall );
+        // Functions do not store their assertions there anymore.
+        for ( ast::ptr<ast::TypeDecl> & type_param : forall ) {
+                auto mut = type_param.get_and_mutate();
+                splice( assertions, mut->assertions );
+        }
+        if ( td->base ) {
+                switch ( td->base->kind ) {
+                case TypeData::Tuple:
+                        buildList( td->base->tuple, returns );
+                        break;
+                default:
+                        returns.push_back( dynamic_cast<ast::DeclWithType *>(
+                                buildDecl(
+                                        td->base,
+                                        "",
+                                        ast::Storage::Classes(),
+                                        (ast::Expr *)nullptr, // bitfieldWidth
+                                        ast::Function::Specs(),
+                                        ast::Linkage::Cforall,
+                                        (ast::Expr *)nullptr // asmName
+                                )
+                        ) );
+                } // switch
+        } else {
+                returns.push_back( new ast::ObjectDecl(
+                        td->location,
+                        "",
+                        new ast::BasicType( ast::BasicType::SignedInt ),
+                        (ast::Init *)nullptr,
+                        ast::Storage::Classes(),
+                        ast::Linkage::Cforall
+                ) );
+        } // if
+        ast::Stmt * stmt = maybeBuild( td->function.body );
+        ast::CompoundStmt * body = dynamic_cast<ast::CompoundStmt *>( stmt );
+        ast::FunctionDecl * decl = new ast::FunctionDecl( td->location,
+                name,
+                std::move( forall ),
+                std::move( assertions ),
+                std::move( params ),
+                std::move( returns ),
+                body,
+                scs,
+                linkage,
+                std::move( attributes ),
+                funcSpec,
+                (isVarArgs) ? ast::VariableArgs : ast::FixedArgs
+        );
+        buildList( td->function.withExprs, decl->withExprs );
+        decl->asmName = asmName;
+        // This may be redundant on a declaration.
+        decl->type.get_and_mutate()->qualifiers = cvq;
+        return decl;
+} // buildFunctionDecl
+ast::Decl * buildDecl(
+                const TypeData * td,
+                const string &name,
+                ast::Storage::Classes scs,
+                ast::Expr * bitfieldWidth,
+                ast::Function::Specs funcSpec,
+                ast::Linkage::Spec linkage,
+                ast::Expr * asmName,
+                ast::Init * init,
+                std::vector<ast::ptr<ast::Attribute>> && attributes ) {
         if ( td->kind == TypeData::Function ) {
                 if ( td->function.idList ) {                                    // KR function ?
 …
                 } // if
+                FunctionDecl * decl;
+                Statement * stmt = maybeBuild<Statement>( td->function.body );
+                CompoundStmt * body = dynamic_cast< CompoundStmt * >( stmt );
+                decl = new FunctionDecl( name, scs, linkage, buildFunction( td ), body, attributes, funcSpec );
+                buildList( td->function.withExprs, decl->withExprs );
+                return decl->set_asmName( asmName );
+                return buildFunctionDecl(
+                        td, name, scs, funcSpec, linkage,
+                        asmName, std::move( attributes ) );
         } else if ( td->kind == TypeData::Aggregate ) {
                 return buildAggregate( td, attributes, linkage );
+                return buildAggregate( td, std::move( attributes ), linkage );
         } else if ( td->kind == TypeData::Enum ) {
                 return buildEnum( td, attributes, linkage );
+                return buildEnum( td, std::move( attributes ), linkage );
         } else if ( td->kind == TypeData::Symbolic ) {
                 return buildSymbolic( td, attributes, name, scs, linkage );
+                return buildSymbolic( td, std::move( attributes ), name, scs, linkage );
         } else {
+                return (new ObjectDecl( name, scs, linkage, bitfieldWidth, typebuild( td ), init, attributes ))->set_asmName( asmName );
+                auto ret = new ast::ObjectDecl( td->location,
+                        name,
+                        typebuild( td ),
+                        init,
+                        scs,
+                        linkage,
+                        bitfieldWidth,
+                        std::move( attributes )
+                );
+                ret->asmName = asmName;
+                return ret;
         } // if
         return nullptr;
 …
 FunctionType * buildFunction( const TypeData * td ) {
+ast::FunctionType * buildFunctionType( const TypeData * td ) {
         assert( td->kind == TypeData::Function );
+        FunctionType * ft = new FunctionType( buildQualifiers( td ), ! td->function.params || td->function.params->hasEllipsis );
+        buildList( td->function.params, ft->parameters );
+        ast::FunctionType * ft = new ast::FunctionType(
+                ( !td->function.params || td->function.params->hasEllipsis )
+                        ? ast::VariableArgs : ast::FixedArgs,
+                buildQualifiers( td )
+        );
+        buildTypeList( td->function.params, ft->params );
         buildForall( td->forall, ft->forall );
         if ( td->base ) {
                 switch ( td->base->kind ) {
                   case TypeData::Tuple:
                         buildList( td->base->tuple, ft->returnVals );
+                case TypeData::Tuple:
+                        buildTypeList( td->base->tuple, ft->returns );
                         break;
+                  default:
+                        ft->get_returnVals().push_back( dynamic_cast< DeclarationWithType * >( buildDecl( td->base, "", Type::StorageClasses(), nullptr, Type::FuncSpecifiers(), LinkageSpec::Cforall, nullptr ) ) );
+                default:
+                        ft->returns.push_back( typebuild( td->base ) );
+                        break;
                 } // switch
         } else {
+                ft->get_returnVals().push_back( new ObjectDecl( "", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), nullptr ) );
+                ft->returns.push_back(
+                        new ast::BasicType( ast::BasicType::SignedInt ) );
         } // if
         return ft;
 } // buildFunction
+} // buildFunctionType
 …
                                 param->type = decl->type;                               // set copy declaration type to parameter type
                                 decl->type = nullptr;                                   // reset declaration type
+                                param->attributes.splice( param->attributes.end(), decl->attributes ); // copy and reset attributes from declaration to parameter
+                                // Copy and reset attributes from declaration to parameter:
+                                splice( param->attributes, decl->attributes );
                         } // if
                 } // for

src/Parser/TypeData.h

-              r34b4268
+              r24d6572
 // Author           : Peter A. Buhr
 // Created On       : Sat May 16 15:18:36 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Tue May 10 22:18:49 2022
 // Update Count     : 203
+// Last Modified By : Andrew Beach
+// Last Modified On : Wed Mar  1 10:44:00 2023
+// Update Count     : 206
 //
 #pragma once
 #include <iosfwd>                                                                               // for ostream
 #include <list>                                                                                 // for list
 #include <string>                                                                               // for string
+#include <iosfwd>                                   // for ostream
+#include <list>                                     // for list
+#include <string>                                   // for string
+#include "ParseNode.h"                                                                  // for DeclarationNode, DeclarationNode::Ag...
+#include "SynTree/LinkageSpec.h"                                                // for Spec
+#include "SynTree/Type.h"                                                               // for Type, ReferenceToType (ptr only)
+#include "SynTree/SynTree.h"                                                    // for Visitor Nodes
+#include "AST/Type.hpp"                             // for Type
+#include "DeclarationNode.h"                        // for DeclarationNode
 struct TypeData {
 …
         struct Aggregate_t {
                 AggregateDecl::Aggregate kind;
+                ast::AggregateDecl::Aggregate kind;
                 const std::string * name = nullptr;
                 DeclarationNode * params = nullptr;
 …
                 bool body;
                 bool anon;
                 bool tagged;
                 const std::string * parent = nullptr;
 …
         DeclarationNode::BuiltinType builtintype = DeclarationNode::NoBuiltinType;
         Type::Qualifiers qualifiers;
+        ast::CV::Qualifiers qualifiers;
         DeclarationNode * forall = nullptr;
 …
 };
 Type * typebuild( const TypeData * );
+ast::Type * typebuild( const TypeData * );
 TypeData * typeextractAggregate( const TypeData * td, bool toplevel = true );
+Type::Qualifiers buildQualifiers( const TypeData * td );
+Type * buildBasicType( const TypeData * );
+PointerType * buildPointer( const TypeData * );
+ArrayType * buildArray( const TypeData * );
+ReferenceType * buildReference( const TypeData * );
+AggregateDecl * buildAggregate( const TypeData *, std::list< Attribute * > );
+ReferenceToType * buildComAggInst( const TypeData *, std::list< Attribute * > attributes, LinkageSpec::Spec linkage );
+ReferenceToType * buildAggInst( const TypeData * );
+TypeDecl * buildVariable( const TypeData * );
+EnumDecl * buildEnum( const TypeData *, std::list< Attribute * >, LinkageSpec::Spec );
+TypeInstType * buildSymbolicInst( const TypeData * );
+TupleType * buildTuple( const TypeData * );
+TypeofType * buildTypeof( const TypeData * );
+VTableType * buildVtable( const TypeData * );
+Declaration * buildDecl( const TypeData *, const std::string &, Type::StorageClasses, Expression *, Type::FuncSpecifiers funcSpec, LinkageSpec::Spec, Expression * asmName,
+                                                 Initializer * init = nullptr, std::list< class Attribute * > attributes = std::list< class Attribute * >() );
+FunctionType * buildFunction( const TypeData * );
+Declaration * addEnumBase( Declaration *, const TypeData * );
+ast::CV::Qualifiers buildQualifiers( const TypeData * td );
+ast::Type * buildBasicType( const TypeData * );
+ast::PointerType * buildPointer( const TypeData * );
+ast::ArrayType * buildArray( const TypeData * );
+ast::ReferenceType * buildReference( const TypeData * );
+ast::AggregateDecl * buildAggregate( const TypeData *, std::vector<ast::ptr<ast::Attribute>> );
+ast::BaseInstType * buildComAggInst( const TypeData *, std::vector<ast::ptr<ast::Attribute>> && attributes, ast::Linkage::Spec linkage );
+ast::BaseInstType * buildAggInst( const TypeData * );
+ast::TypeDecl * buildVariable( const TypeData * );
+ast::EnumDecl * buildEnum( const TypeData *, std::vector<ast::ptr<ast::Attribute>> &&, ast::Linkage::Spec );
+ast::TypeInstType * buildSymbolicInst( const TypeData * );
+ast::TupleType * buildTuple( const TypeData * );
+ast::TypeofType * buildTypeof( const TypeData * );
+ast::VTableType * buildVtable( const TypeData * );
+ast::Decl * buildDecl(
+        const TypeData *, const std::string &, ast::Storage::Classes, ast::Expr *,
+        ast::Function::Specs funcSpec, ast::Linkage::Spec, ast::Expr * asmName,
+        ast::Init * init = nullptr, std::vector<ast::ptr<ast::Attribute>> && attributes = std::vector<ast::ptr<ast::Attribute>>() );
+ast::FunctionType * buildFunctionType( const TypeData * );
+ast::Decl * addEnumBase( Declaration *, const TypeData * );
 void buildKRFunction( const TypeData::Function_t & function );

src/Parser/TypedefTable.cc

-              r34b4268
+              r24d6572
 #include "TypedefTable.h"
+#include <cassert>                                                                              // for assert
+#include <iostream>
+#include <cassert>                                // for assert
+#include <string>                                 // for string
+#include <iostream>                               // for iostream
+#include "ExpressionNode.h"                       // for LabelNode
+#include "ParserTypes.h"                          // for Token
+#include "StatementNode.h"                        // for CondCtl, ForCtrl
+// This (generated) header must come late as it is missing includes.
+#include "parser.hh"              // for IDENTIFIER, TYPEDEFname, TYPEGENname
 using namespace std;
 #if 0
 #define debugPrint( code ) code
+static const char *kindName( int kind ) {
+        switch ( kind ) {
+        case IDENTIFIER: return "identifier";
+        case TYPEDIMname: return "typedim";
+        case TYPEDEFname: return "typedef";
+        case TYPEGENname: return "typegen";
+        default:
+                cerr << "Error: cfa-cpp internal error, invalid kind of identifier" << endl;
+                abort();
+        } // switch
+} // kindName
 #else
 #define debugPrint( code )
 #endif
-using namespace std;                                                                    // string, iostream
-debugPrint(
-        static const char *kindName( int kind ) {
-                switch ( kind ) {
-                  case IDENTIFIER: return "identifier";
-                  case TYPEDIMname: return "typedim";
-                  case TYPEDEFname: return "typedef";
-                  case TYPEGENname: return "typegen";
-                  default:
-                        cerr << "Error: cfa-cpp internal error, invalid kind of identifier" << endl;
-                        abort();
-                } // switch
-        } // kindName
-);
 TypedefTable::~TypedefTable() {
 …
                 typedefTable.addToEnclosingScope( name, kind, "MTD" );
         } // if
+} // TypedefTable::makeTypedef
+void TypedefTable::makeTypedef( const string & name ) {
+        return makeTypedef( name, TYPEDEFname );
 } // TypedefTable::makeTypedef

src/Parser/TypedefTable.h

-              r34b4268
+              r24d6572
 #include "Common/ScopedMap.h"                                                   // for ScopedMap
-#include "ParserTypes.h"
-#include "parser.hh"                                                                    // for IDENTIFIER, TYPEDEFname, TYPEGENname
 class TypedefTable {
         struct Note { size_t level; bool forall; };
         typedef ScopedMap< std::string, int, Note > KindTable;
         KindTable kindTable;
+        KindTable kindTable;
         unsigned int level = 0;
   public:
 …
         bool existsCurr( const std::string & identifier ) const;
         int isKind( const std::string & identifier ) const;
+        void makeTypedef( const std::string & name, int kind = TYPEDEFname );
+        void makeTypedef( const std::string & name, int kind );
+        void makeTypedef( const std::string & name );
         void addToScope( const std::string & identifier, int kind, const char * );
         void addToEnclosingScope( const std::string & identifier, int kind, const char * );

src/Parser/lex.ll

-              r34b4268
+              r24d6572
  * Created On       : Sat Sep 22 08:58:10 2001
  * Last Modified By : Peter A. Buhr
  * Last Modified On : Thu Oct 13 20:46:04 2022
  * Update Count     : 764
+ * Last Modified On : Tue May  2 08:45:21 2023
+ * Update Count     : 769
  */
 …
 // line-number directives) and C/C++ style comments, which are ignored.
 //**************************** Includes and Defines ****************************
+// *************************** Includes and Defines ****************************
 #ifdef __clang__
 …
 #include "config.h"                                                                             // configure info
+#include "DeclarationNode.h"                            // for DeclarationNode
+#include "ExpressionNode.h"                             // for LabelNode
+#include "InitializerNode.h"                            // for InitializerNode
 #include "ParseNode.h"
+#include "ParserTypes.h"                                // for Token
+#include "StatementNode.h"                              // for CondCtl, ForCtrl
 #include "TypedefTable.h"
+// This (generated) header must come late as it is missing includes.
+#include "parser.hh"                                    // generated info
 string * build_postfix_name( string * name );
 …
 __alignof               { KEYWORD_RETURN(ALIGNOF); }                    // GCC
 __alignof__             { KEYWORD_RETURN(ALIGNOF); }                    // GCC
+and                             { QKEYWORD_RETURN(WAND); }                              // CFA
 asm                             { KEYWORD_RETURN(ASM); }
 __asm                   { KEYWORD_RETURN(ASM); }                                // GCC
 …
 enable                  { KEYWORD_RETURN(ENABLE); }                             // CFA
 enum                    { KEYWORD_RETURN(ENUM); }
+exception               { KEYWORD_RETURN(EXCEPTION); }                  // CFA
 __extension__   { KEYWORD_RETURN(EXTENSION); }                  // GCC
-exception               { KEYWORD_RETURN(EXCEPTION); }                  // CFA
 extern                  { KEYWORD_RETURN(EXTERN); }
 fallthrough             { KEYWORD_RETURN(FALLTHROUGH); }                // CFA
 …
 vtable                  { KEYWORD_RETURN(VTABLE); }                             // CFA
 waitfor                 { KEYWORD_RETURN(WAITFOR); }                    // CFA
+waituntil               { KEYWORD_RETURN(WAITUNTIL); }                  // CFA
 when                    { KEYWORD_RETURN(WHEN); }                               // CFA
 while                   { KEYWORD_RETURN(WHILE); }
 …
         SemanticErrorThrow = true;
         cerr << (yyfilename ? yyfilename : "*unknown file*") << ':' << yylineno << ':' << column - yyleng + 1
                  << ": " << ErrorHelpers::error_str() << errmsg << " at token \"" << (yytext[0] == '\0' ? "EOF" : yytext) << '"' << endl;
+                 << ": " << ErrorHelpers::error_str() << errmsg << " before token \"" << (yytext[0] == '\0' ? "EOF" : yytext) << '"' << endl;
+}

src/Parser/module.mk

-              r34b4268
+              r24d6572
 SRC += \
        Parser/DeclarationNode.cc \
+       Parser/DeclarationNode.h \
        Parser/ExpressionNode.cc \
+       Parser/ExpressionNode.h \
        Parser/InitializerNode.cc \
+       Parser/InitializerNode.h \
        Parser/lex.ll \
        Parser/ParseNode.cc \
 …
        Parser/parserutility.cc \
        Parser/parserutility.h \
+       Parser/RunParser.cpp \
+       Parser/RunParser.hpp \
        Parser/StatementNode.cc \
+       Parser/StatementNode.h \
        Parser/TypeData.cc \
        Parser/TypeData.h \

src/Parser/parser.yy

-              r34b4268
+              r24d6572
 // Created On       : Sat Sep  1 20:22:55 2001
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Mon Nov 21 22:34:30 2022
 // Update Count     : 5848
+// Last Modified On : Wed Apr 26 16:45:37 2023
+// Update Count     : 6330
 //
 …
 #include <cstdio>
+#include <sstream>
 #include <stack>
 using namespace std;
+#include "SynTree/Declaration.h"
+#include "ParseNode.h"
+#include "SynTree/Type.h"                               // for Type
+#include "DeclarationNode.h"                            // for DeclarationNode, ...
+#include "ExpressionNode.h"                             // for ExpressionNode, ...
+#include "InitializerNode.h"                            // for InitializerNode, ...
+#include "ParserTypes.h"
+#include "StatementNode.h"                              // for build_...
 #include "TypedefTable.h"
 #include "TypeData.h"
-#include "SynTree/LinkageSpec.h"
 #include "Common/SemanticError.h"                                               // error_str
 #include "Common/utility.h"                                                             // for maybeMoveBuild, maybeBuild, CodeLo...
 #include "SynTree/Attribute.h"     // for Attribute
+#include "SynTree/Attribute.h"                                                  // for Attribute
 // lex uses __null in a boolean context, it's fine.
 …
 extern DeclarationNode * parseTree;
 extern LinkageSpec::Spec linkage;
+extern ast::Linkage::Spec linkage;
 extern TypedefTable typedefTable;
 stack<LinkageSpec::Spec> linkageStack;
+stack<ast::Linkage::Spec> linkageStack;
 bool appendStr( string & to, string & from ) {
 …
 } // fieldDecl
 #define NEW_ZERO new ExpressionNode( build_constantInteger( *new string( "0" ) ) )
 #define NEW_ONE  new ExpressionNode( build_constantInteger( *new string( "1" ) ) )
+#define NEW_ZERO new ExpressionNode( build_constantInteger( yylloc, *new string( "0" ) ) )
+#define NEW_ONE  new ExpressionNode( build_constantInteger( yylloc, *new string( "1" ) ) )
 #define UPDOWN( compop, left, right ) (compop == OperKinds::LThan || compop == OperKinds::LEThan ? left : right)
 #define MISSING_ANON_FIELD "Missing loop fields with an anonymous loop index is meaningless as loop index is unavailable in loop body."
 …
 #define MISSING_HIGH "Missing high value for down-to range so index is uninitialized."
+ForCtrl * forCtrl( DeclarationNode * index, ExpressionNode * start, enum OperKinds compop, ExpressionNode * comp, ExpressionNode * inc ) {
+static ForCtrl * makeForCtrl(
+                const CodeLocation & location,
+                DeclarationNode * init,
+                enum OperKinds compop,
+                ExpressionNode * comp,
+                ExpressionNode * inc ) {
+        // Wrap both comp/inc if they are non-null.
+        if ( comp ) comp = new ExpressionNode( build_binary_val( location,
+                compop,
+                new ExpressionNode( build_varref( location, new string( *init->name ) ) ),
+                comp ) );
+        if ( inc ) inc = new ExpressionNode( build_binary_val( location,
+                // choose += or -= for upto/downto
+                compop == OperKinds::LThan || compop == OperKinds::LEThan ? OperKinds::PlusAssn : OperKinds::MinusAssn,
+                new ExpressionNode( build_varref( location, new string( *init->name ) ) ),
+                inc ) );
+        // The StatementNode call frees init->name, it must happen later.
+        return new ForCtrl( new StatementNode( init ), comp, inc );
+}
+ForCtrl * forCtrl( const CodeLocation & location, DeclarationNode * index, ExpressionNode * start, enum OperKinds compop, ExpressionNode * comp, ExpressionNode * inc ) {
         if ( index->initializer ) {
                 SemanticError( yylloc, "Direct initialization disallowed. Use instead: type var; initialization ~ comparison ~ increment." );
 …
                 SemanticError( yylloc, "Multiple loop indexes disallowed in for-loop declaration." );
         } // if
+        return new ForCtrl( index->addInitializer( new InitializerNode( start ) ),
+                // NULL comp/inc => leave blank
+                comp ? new ExpressionNode( build_binary_val( compop, new ExpressionNode( build_varref( new string( *index->name ) ) ), comp ) ) : nullptr,
+                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->name ) ) ), inc ) ) : nullptr );
+        DeclarationNode * initDecl = index->addInitializer( new InitializerNode( start ) );
+        return makeForCtrl( location, initDecl, compop, comp, inc );
 } // forCtrl
 ForCtrl * forCtrl( ExpressionNode * type, string * index, ExpressionNode * start, enum OperKinds compop, ExpressionNode * comp, ExpressionNode * inc ) {
         ConstantExpr * constant = dynamic_cast<ConstantExpr *>(type->expr.get());
         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 ) ) );
+ForCtrl * forCtrl( const CodeLocation & location, ExpressionNode * type, string * index, ExpressionNode * start, enum OperKinds compop, ExpressionNode * comp, ExpressionNode * inc ) {
+        ast::ConstantExpr * constant = dynamic_cast<ast::ConstantExpr *>(type->expr.get());
+        if ( constant && (constant->rep == "0" || constant->rep == "1") ) {
+                type = new ExpressionNode( new ast::CastExpr( location, maybeMoveBuild(type), new ast::BasicType( ast::BasicType::SignedInt ) ) );
         } // if
+//      type = new ExpressionNode( build_func( new ExpressionNode( build_varref( new string( "__for_control_index_constraints__" ) ) ), type ) );
+        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 ) ) : nullptr,
+                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 ) ) : nullptr );
+        DeclarationNode * initDecl = distAttr(
+                DeclarationNode::newTypeof( type, true ),
+                DeclarationNode::newName( index )->addInitializer( new InitializerNode( start ) )
+        );
+        return makeForCtrl( location, initDecl, compop, comp, 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()) ) {
                 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 );
+ForCtrl * forCtrl( const CodeLocation & location, ExpressionNode * type, ExpressionNode * index, ExpressionNode * start, enum OperKinds compop, ExpressionNode * comp, ExpressionNode * inc ) {
+        if ( auto identifier = dynamic_cast<ast::NameExpr *>(index->expr.get()) ) {
+                return forCtrl( location, type, new string( identifier->name ), start, compop, comp, inc );
+        } else if ( auto commaExpr = dynamic_cast<ast::CommaExpr *>( index->expr.get() ) ) {
+                if ( auto identifier = commaExpr->arg1.as<ast::NameExpr>() ) {
+                        return forCtrl( location, type, new string( identifier->name ), start, compop, comp, inc );
                 } else {
                         SemanticError( yylloc, "Expression disallowed. Only loop-index name allowed." ); return nullptr;
 …
 %union {
         Token tok;
+        ParseNode * pn;
+        ExpressionNode * en;
+        ExpressionNode * expr;
         DeclarationNode * decl;
+        AggregateDecl::Aggregate aggKey;
+        TypeDecl::Kind tclass;
+        StatementNode * sn;
+        WaitForStmt * wfs;
+        Expression * constant;
+        ast::AggregateDecl::Aggregate aggKey;
+        ast::TypeDecl::Kind tclass;
+        StatementNode * stmt;
+        ClauseNode * clause;
+        ast::WaitForStmt * wfs;
+    ast::WaitUntilStmt::ClauseNode * wucn;
         CondCtl * ifctl;
+        ForCtrl * fctl;
+        OperKinds compop;
+        LabelNode * label;
+        InitializerNode * in;
+        OperKinds op;
+        ForCtrl * forctl;
+        LabelNode * labels;
+        InitializerNode * init;
+        OperKinds oper;
         std::string * str;
         bool flag;
         EnumHiding hide;
         CatchStmt::Kind catch_kind;
         GenericExpr * genexpr;
+        bool is_volatile;
+        EnumHiding enum_hiding;
+        ast::ExceptionKind except_kind;
+        ast::GenericExpr * genexpr;
+}
 //************************* TERMINAL TOKENS ********************************
+// ************************ TERMINAL TOKENS ********************************
 // keywords
 …
 %token ATTRIBUTE EXTENSION                                                              // GCC
 %token IF ELSE SWITCH CASE DEFAULT DO WHILE FOR BREAK CONTINUE GOTO RETURN
 %token CHOOSE FALLTHRU FALLTHROUGH WITH WHEN WAITFOR    // CFA
+%token CHOOSE FALLTHRU FALLTHROUGH WITH WHEN WAITFOR WAITUNTIL // CFA
 %token DISABLE ENABLE TRY THROW THROWRESUME AT                  // CFA
 %token ASM                                                                                              // C99, extension ISO/IEC 9899:1999 Section J.5.10(1)
 …
 // names and constants: lexer differentiates between identifier and typedef names
 %token<tok> IDENTIFIER          QUOTED_IDENTIFIER       TYPEDIMname             TYPEDEFname             TYPEGENname
 %token<tok> TIMEOUT                     WOR                                     CATCH                   RECOVER                 CATCHRESUME             FIXUP           FINALLY         // CFA
+%token<tok> IDENTIFIER          TYPEDIMname             TYPEDEFname             TYPEGENname
+%token<tok> TIMEOUT                     WAND    WOR                     CATCH                   RECOVER                 CATCHRESUME             FIXUP           FINALLY         // CFA
 %token<tok> INTEGERconstant     CHARACTERconstant       STRINGliteral
 %token<tok> DIRECTIVE
 …
 %type<tok> identifier                                   identifier_at                           identifier_or_type_name         attr_name
 %type<tok> quasi_keyword
 %type<constant> string_literal
+%type<expr> string_literal
 %type<str> string_literal_list
 %type<hide> hide_opt                                    visible_hide_opt
+%type<enum_hiding> hide_opt                                     visible_hide_opt
 // expressions
 %type<en> constant
 %type<en> tuple                                                 tuple_expression_list
 %type<op> ptrref_operator                               unary_operator                          assignment_operator                     simple_assignment_operator      compound_assignment_operator
 %type<en> primary_expression                    postfix_expression                      unary_expression
 %type<en> cast_expression_list                  cast_expression                         exponential_expression          multiplicative_expression       additive_expression
 %type<en> shift_expression                              relational_expression           equality_expression
 %type<en> AND_expression                                exclusive_OR_expression         inclusive_OR_expression
 %type<en> logical_AND_expression                logical_OR_expression
 %type<en> conditional_expression                constant_expression                     assignment_expression           assignment_expression_opt
 %type<en> comma_expression                              comma_expression_opt
 %type<en> argument_expression_list_opt  argument_expression_list        argument_expression                     default_initializer_opt
+%type<expr> constant
+%type<expr> tuple                                                       tuple_expression_list
+%type<oper> ptrref_operator                             unary_operator                          assignment_operator                     simple_assignment_operator      compound_assignment_operator
+%type<expr> primary_expression                  postfix_expression                      unary_expression
+%type<expr> cast_expression_list                        cast_expression                         exponential_expression          multiplicative_expression       additive_expression
+%type<expr> shift_expression                            relational_expression           equality_expression
+%type<expr> AND_expression                              exclusive_OR_expression         inclusive_OR_expression
+%type<expr> logical_AND_expression              logical_OR_expression
+%type<expr> conditional_expression              constant_expression                     assignment_expression           assignment_expression_opt
+%type<expr> comma_expression                            comma_expression_opt
+%type<expr> argument_expression_list_opt        argument_expression_list        argument_expression                     default_initializer_opt
 %type<ifctl> conditional_declaration
 %type<fctl> for_control_expression              for_control_expression_list
 %type<compop> upupeq updown updowneq downupdowneq
 %type<en> subrange
+%type<forctl> for_control_expression            for_control_expression_list
+%type<oper> upupeq updown updowneq downupdowneq
+%type<expr> subrange
 %type<decl> asm_name_opt
 %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<expr> asm_operands_opt                            asm_operands_list                       asm_operand
+%type<labels> label_list
+%type<expr> asm_clobbers_list_opt
+%type<is_volatile> asm_volatile_opt
+%type<expr> handler_predicate_opt
 %type<genexpr> generic_association              generic_assoc_list
 // statements
+%type<sn> statement                                             labeled_statement                       compound_statement
+%type<sn> statement_decl                                statement_decl_list                     statement_list_nodecl
+%type<sn> selection_statement                   if_statement
+%type<sn> switch_clause_list_opt                switch_clause_list
+%type<en> case_value
+%type<sn> case_clause                                   case_value_list                         case_label                                      case_label_list
+%type<sn> iteration_statement                   jump_statement
+%type<sn> expression_statement                  asm_statement
+%type<sn> with_statement
+%type<en> with_clause_opt
+%type<sn> exception_statement                   handler_clause                          finally_clause
+%type<catch_kind> handler_key
+%type<sn> mutex_statement
+%type<en> when_clause                                   when_clause_opt                         waitfor                                         timeout
+%type<sn> waitfor_statement
+%type<wfs> waitfor_clause
+%type<stmt> statement                                           labeled_statement                       compound_statement
+%type<stmt> statement_decl                              statement_decl_list                     statement_list_nodecl
+%type<stmt> selection_statement                 if_statement
+%type<clause> switch_clause_list_opt            switch_clause_list
+%type<expr> case_value
+%type<clause> case_clause                               case_value_list                         case_label                                      case_label_list
+%type<stmt> iteration_statement                 jump_statement
+%type<stmt> expression_statement                        asm_statement
+%type<stmt> with_statement
+%type<expr> with_clause_opt
+%type<stmt> exception_statement
+%type<clause> handler_clause                    finally_clause
+%type<except_kind> handler_key
+%type<stmt> mutex_statement
+%type<expr> when_clause                                 when_clause_opt                         waitfor         waituntil               timeout
+%type<stmt> waitfor_statement                           waituntil_statement
+%type<wfs> wor_waitfor_clause
+%type<wucn> waituntil_clause                    wand_waituntil_clause       wor_waituntil_clause
 // declarations
 …
 %type<decl> assertion assertion_list assertion_list_opt
 %type<en> bit_subrange_size_opt bit_subrange_size
+%type<expr> bit_subrange_size_opt bit_subrange_size
 %type<decl> basic_declaration_specifier basic_type_name basic_type_specifier direct_type indirect_type
 …
 %type<decl> enumerator_list enum_type enum_type_nobody
 %type<in> enumerator_value_opt
+%type<init> enumerator_value_opt
 %type<decl> external_definition external_definition_list external_definition_list_opt
 …
 %type<decl> field_declaration_list_opt field_declaration field_declaring_list_opt field_declarator field_abstract_list_opt field_abstract
 %type<en> field field_name_list field_name fraction_constants_opt
+%type<expr> field field_name_list field_name fraction_constants_opt
 %type<decl> external_function_definition function_definition function_array function_declarator function_no_ptr function_ptr
 …
 %type<decl> typedef_name typedef_declaration typedef_expression
+%type<decl> variable_type_redeclarator type_ptr type_array type_function
+%type<decl> variable_type_redeclarator variable_type_ptr variable_type_array variable_type_function
+%type<decl> general_function_declarator function_type_redeclarator function_type_array function_type_no_ptr function_type_ptr
 %type<decl> type_parameter_redeclarator type_parameter_ptr type_parameter_array type_parameter_function
 …
 %type<decl> type_parameter type_parameter_list type_initializer_opt
 %type<en> type_parameters_opt type_list array_type_list
+%type<expr> type_parameters_opt type_list array_type_list
 %type<decl> type_qualifier type_qualifier_name forall type_qualifier_list_opt type_qualifier_list
 …
 // initializers
 %type<in>  initializer initializer_list_opt initializer_opt
+%type<init>  initializer initializer_list_opt initializer_opt
 // designators
 %type<en>  designator designator_list designation
+%type<expr>  designator designator_list designation
 …
 // Similar issues exit with the waitfor statement.
 // Order of these lines matters (low-to-high precedence). THEN is left associative over WOR/TIMEOUT/ELSE, WOR is left
 // associative over TIMEOUT/ELSE, and TIMEOUT is left associative over ELSE.
+// Order of these lines matters (low-to-high precedence). THEN is left associative over WAND/WOR/TIMEOUT/ELSE, WAND/WOR
+// is left associative over TIMEOUT/ELSE, and TIMEOUT is left associative over ELSE.
 %precedence THEN                // rule precedence for IF/WAITFOR statement
+%precedence ANDAND              // token precedence for start of WAND in WAITFOR statement
+%precedence WAND                // token precedence for start of WAND in WAITFOR statement
+%precedence OROR                // token precedence for start of WOR in WAITFOR statement
 %precedence WOR                 // token precedence for start of WOR in WAITFOR statement
 %precedence TIMEOUT             // token precedence for start of TIMEOUT in WAITFOR statement
 …
 constant:
                 // ENUMERATIONconstant is not included here; it is treated as a variable with type "enumeration constant".
         INTEGERconstant                                                         { $$ = new ExpressionNode( build_constantInteger( *$1 ) ); }
         | FLOATING_DECIMALconstant                                      { $$ = new ExpressionNode( build_constantFloat( *$1 ) ); }
         | FLOATING_FRACTIONconstant                                     { $$ = new ExpressionNode( build_constantFloat( *$1 ) ); }
         | FLOATINGconstant                                                      { $$ = new ExpressionNode( build_constantFloat( *$1 ) ); }
         | CHARACTERconstant                                                     { $$ = new ExpressionNode( build_constantChar( *$1 ) ); }
+        INTEGERconstant                                                         { $$ = new ExpressionNode( build_constantInteger( yylloc, *$1 ) ); }
+        | FLOATING_DECIMALconstant                                      { $$ = new ExpressionNode( build_constantFloat( yylloc, *$1 ) ); }
+        | FLOATING_FRACTIONconstant                                     { $$ = new ExpressionNode( build_constantFloat( yylloc, *$1 ) ); }
+        | FLOATINGconstant                                                      { $$ = new ExpressionNode( build_constantFloat( yylloc, *$1 ) ); }
+        | CHARACTERconstant                                                     { $$ = new ExpressionNode( build_constantChar( yylloc, *$1 ) ); }
+        ;
 quasi_keyword:                                                                                  // CFA
         TIMEOUT
+        | WAND
         | WOR
         | CATCH
 …
 string_literal:
         string_literal_list                                                     { $$ = build_constantStr( *$1 ); }
+        string_literal_list                                                     { $$ = new ExpressionNode( build_constantStr( yylloc, *$1 ) ); }
+        ;
 …
 primary_expression:
         IDENTIFIER                                                                                      // typedef name cannot be used as a variable name
                 { $$ = new ExpressionNode( build_varref( $1 ) ); }
+                { $$ = new ExpressionNode( build_varref( yylloc, $1 ) ); }
         | quasi_keyword
                 { $$ = new ExpressionNode( build_varref( $1 ) ); }
+                { $$ = new ExpressionNode( build_varref( yylloc, $1 ) ); }
         | TYPEDIMname                                                                           // CFA, generic length argument
                 // { $$ = new ExpressionNode( new TypeExpr( maybeMoveBuildType( DeclarationNode::newFromTypedef( $1 ) ) ) ); }
                 // { $$ = new ExpressionNode( build_varref( $1 ) ); }
                 { $$ = new ExpressionNode( build_dimensionref( $1 ) ); }
+                { $$ = new ExpressionNode( build_dimensionref( yylloc, $1 ) ); }
         | tuple
         | '(' comma_expression ')'
                 { $$ = $2; }
         | '(' compound_statement ')'                                            // GCC, lambda expression
                 { $$ = new ExpressionNode( new StmtExpr( dynamic_cast<CompoundStmt *>(maybeMoveBuild<Statement>($2) ) ) ); }
+                { $$ = new ExpressionNode( new ast::StmtExpr( yylloc, dynamic_cast<ast::CompoundStmt *>( maybeMoveBuild( $2 ) ) ) ); }
         | type_name '.' identifier                                                      // CFA, nested type
                 { $$ = new ExpressionNode( build_qualified_expr( $1, build_varref( $3 ) ) ); }
+                { $$ = new ExpressionNode( build_qualified_expr( yylloc, $1, build_varref( yylloc, $3 ) ) ); }
         | type_name '.' '[' field_name_list ']'                         // CFA, nested type / tuple field selector
                 { SemanticError( yylloc, "Qualified name is currently unimplemented." ); $$ = nullptr; }
 …
+                {
                         // add the missing control expression to the GenericExpr and return it
                         $5->control = maybeMoveBuild<Expression>( $3 );
+                        $5->control = maybeMoveBuild( $3 );
                         $$ = new ExpressionNode( $5 );
+                }
 …
+                {
                         // steal the association node from the singleton and delete the wrapper
+                        $1->associations.splice($1->associations.end(), $3->associations);
+                        assert( 1 == $3->associations.size() );
+                        $1->associations.push_back( $3->associations.front() );
                         delete $3;
                         $$ = $1;
 …
+                {
                         // create a GenericExpr wrapper with one association pair
                         $$ = new GenericExpr( nullptr, { { maybeMoveBuildType($1), maybeMoveBuild<Expression>( $3 ) } } );
+                        $$ = new ast::GenericExpr( yylloc, nullptr, { { maybeMoveBuildType( $1 ), maybeMoveBuild( $3 ) } } );
+                }
         | DEFAULT ':' assignment_expression
                 { $$ = new GenericExpr( nullptr, { { maybeMoveBuild<Expression>( $3 ) } } ); }
+                { $$ = new ast::GenericExpr( yylloc, nullptr, { { maybeMoveBuild( $3 ) } } ); }
+        ;
 …
                 // Switching to this behaviour may help check if a C compatibilty case uses comma-exprs in subscripts.
                 // Current: Commas in subscripts make tuples.
                 { $$ = new ExpressionNode( build_binary_val( OperKinds::Index, $1, new ExpressionNode( build_tuple( (ExpressionNode *)($3->set_last( $5 ) ) )) ) ); }
+                { $$ = new ExpressionNode( build_binary_val( yylloc, OperKinds::Index, $1, new ExpressionNode( build_tuple( yylloc, (ExpressionNode *)($3->set_last( $5 ) ) )) ) ); }
         | postfix_expression '[' assignment_expression ']'
                 // CFA, comma_expression disallowed in this context because it results in a common user error: subscripting a
 …
                 // little advantage to this feature and many disadvantages. It is possible to write x[(i,j)] in CFA, which is
                 // equivalent to the old x[i,j].
                 { $$ = new ExpressionNode( build_binary_val( OperKinds::Index, $1, $3 ) ); }
+                { $$ = new ExpressionNode( build_binary_val( yylloc, OperKinds::Index, $1, $3 ) ); }
         | constant '[' assignment_expression ']'                        // 3[a], 'a'[a], 3.5[a]
                 { $$ = new ExpressionNode( build_binary_val( OperKinds::Index, $1, $3 ) ); }
+                { $$ = new ExpressionNode( build_binary_val( yylloc, OperKinds::Index, $1, $3 ) ); }
         | string_literal '[' assignment_expression ']'          // "abc"[3], 3["abc"]
                 { $$ = new ExpressionNode( build_binary_val( OperKinds::Index, new ExpressionNode( $1 ), $3 ) ); }
+                { $$ = new ExpressionNode( build_binary_val( yylloc, OperKinds::Index, $1, $3 ) ); }
         | postfix_expression '{' argument_expression_list_opt '}' // CFA, constructor call
+                {
                         Token fn;
                         fn.str = new std::string( "?{}" );                      // location undefined - use location of '{'?
                         $$ = new ExpressionNode( new ConstructorExpr( build_func( new ExpressionNode( build_varref( fn ) ), (ExpressionNode *)( $1 )->set_last( $3 ) ) ) );
+                        $$ = new ExpressionNode( new ast::ConstructorExpr( yylloc, build_func( yylloc, new ExpressionNode( build_varref( yylloc, fn ) ), (ExpressionNode *)( $1 )->set_last( $3 ) ) ) );
+                }
         | postfix_expression '(' argument_expression_list_opt ')'
                 { $$ = new ExpressionNode( build_func( $1, $3 ) ); }
+                { $$ = new ExpressionNode( build_func( yylloc, $1, $3 ) ); }
         | VA_ARG '(' primary_expression ',' declaration_specifier_nobody abstract_parameter_declarator_opt ')'
                 // { SemanticError( yylloc, "va_arg is currently unimplemented." ); $$ = nullptr; }
                 { $$ = new ExpressionNode( build_func( new ExpressionNode( build_varref( new string( "__builtin_va_arg") ) ),
+                { $$ = new ExpressionNode( build_func( yylloc, new ExpressionNode( build_varref( yylloc, new string( "__builtin_va_arg") ) ),
                                                                                            (ExpressionNode *)($3->set_last( (ExpressionNode *)($6 ? $6->addType( $5 ) : $5) )) ) ); }
         | postfix_expression '`' identifier                                     // CFA, postfix call
                 { $$ = new ExpressionNode( build_func( new ExpressionNode( build_varref( build_postfix_name( $3 ) ) ), $1 ) ); }
+                { $$ = new ExpressionNode( build_func( yylloc, new ExpressionNode( build_varref( yylloc, build_postfix_name( $3 ) ) ), $1 ) ); }
         | constant '`' identifier                                                       // CFA, postfix call
                 { $$ = new ExpressionNode( build_func( new ExpressionNode( build_varref( build_postfix_name( $3 ) ) ), $1 ) ); }
+                { $$ = new ExpressionNode( build_func( yylloc, new ExpressionNode( build_varref( yylloc, build_postfix_name( $3 ) ) ), $1 ) ); }
         | string_literal '`' identifier                                         // CFA, postfix call
                 { $$ = new ExpressionNode( build_func( new ExpressionNode( build_varref( build_postfix_name( $3 ) ) ), new ExpressionNode( $1 ) ) ); }
+                { $$ = new ExpressionNode( build_func( yylloc, new ExpressionNode( build_varref( yylloc, build_postfix_name( $3 ) ) ), $1 ) ); }
         | postfix_expression '.' identifier
                 { $$ = new ExpressionNode( build_fieldSel( $1, build_varref( $3 ) ) ); }
+                { $$ = new ExpressionNode( build_fieldSel( yylloc, $1, build_varref( yylloc, $3 ) ) ); }
         | postfix_expression '.' INTEGERconstant                        // CFA, tuple index
                 { $$ = new ExpressionNode( build_fieldSel( $1, build_constantInteger( *$3 ) ) ); }
+                { $$ = new ExpressionNode( build_fieldSel( yylloc, $1, build_constantInteger( yylloc, *$3 ) ) ); }
         | postfix_expression FLOATING_FRACTIONconstant          // CFA, tuple index
                 { $$ = new ExpressionNode( build_fieldSel( $1, build_field_name_FLOATING_FRACTIONconstant( *$2 ) ) ); }
+                { $$ = new ExpressionNode( build_fieldSel( yylloc, $1, build_field_name_FLOATING_FRACTIONconstant( yylloc, *$2 ) ) ); }
         | postfix_expression '.' '[' field_name_list ']'        // CFA, tuple field selector
                 { $$ = new ExpressionNode( build_fieldSel( $1, build_tuple( $4 ) ) ); }
+                { $$ = new ExpressionNode( build_fieldSel( yylloc, $1, build_tuple( yylloc, $4 ) ) ); }
         | postfix_expression '.' aggregate_control
                 { $$ = new ExpressionNode( build_keyword_cast( $3, $1 ) ); }
+                { $$ = new ExpressionNode( build_keyword_cast( yylloc, $3, $1 ) ); }
         | postfix_expression ARROW identifier
                 { $$ = new ExpressionNode( build_pfieldSel( $1, build_varref( $3 ) ) ); }
+                { $$ = new ExpressionNode( build_pfieldSel( yylloc, $1, build_varref( yylloc, $3 ) ) ); }
         | postfix_expression ARROW INTEGERconstant                      // CFA, tuple index
                 { $$ = new ExpressionNode( build_pfieldSel( $1, build_constantInteger( *$3 ) ) ); }
+                { $$ = new ExpressionNode( build_pfieldSel( yylloc, $1, build_constantInteger( yylloc, *$3 ) ) ); }
         | postfix_expression ARROW '[' field_name_list ']'      // CFA, tuple field selector
                 { $$ = new ExpressionNode( build_pfieldSel( $1, build_tuple( $4 ) ) ); }
+                { $$ = new ExpressionNode( build_pfieldSel( yylloc, $1, build_tuple( yylloc, $4 ) ) ); }
         | postfix_expression ICR
                 { $$ = new ExpressionNode( build_unary_ptr( OperKinds::IncrPost, $1 ) ); }
+                { $$ = new ExpressionNode( build_unary_val( yylloc, OperKinds::IncrPost, $1 ) ); }
         | postfix_expression DECR
                 { $$ = new ExpressionNode( build_unary_ptr( OperKinds::DecrPost, $1 ) ); }
+                { $$ = new ExpressionNode( build_unary_val( yylloc, OperKinds::DecrPost, $1 ) ); }
         | '(' type_no_function ')' '{' initializer_list_opt comma_opt '}' // C99, compound-literal
                 { $$ = new ExpressionNode( build_compoundLiteral( $2, new InitializerNode( $5, true ) ) ); }
+                { $$ = new ExpressionNode( build_compoundLiteral( yylloc, $2, new InitializerNode( $5, true ) ) ); }
         | '(' type_no_function ')' '@' '{' initializer_list_opt comma_opt '}' // CFA, explicit C compound-literal
                 { $$ = new ExpressionNode( build_compoundLiteral( $2, (new InitializerNode( $6, true ))->set_maybeConstructed( false ) ) ); }
+                { $$ = new ExpressionNode( build_compoundLiteral( yylloc, $2, (new InitializerNode( $6, true ))->set_maybeConstructed( false ) ) ); }
         | '^' primary_expression '{' argument_expression_list_opt '}' // CFA, destructor call
+                {
                         Token fn;
                         fn.str = new string( "^?{}" );                          // location undefined
                         $$ = new ExpressionNode( build_func( new ExpressionNode( build_varref( fn ) ), (ExpressionNode *)( $2 )->set_last( $4 ) ) );
+                        $$ = new ExpressionNode( build_func( yylloc, new ExpressionNode( build_varref( yylloc, fn ) ), (ExpressionNode *)( $2 )->set_last( $4 ) ) );
+                }
+        ;
 …
         '@'                                                                                                     // CFA, default parameter
                 { SemanticError( yylloc, "Default parameter for argument is currently unimplemented." ); $$ = nullptr; }
                 // { $$ = new ExpressionNode( build_constantInteger( *new string( "2" ) ) ); }
+                // { $$ = new ExpressionNode( build_constantInteger( *new string( "2" ) ) ); }
         | assignment_expression
+        ;
 …
         field_name
         | FLOATING_DECIMALconstant field
                 { $$ = new ExpressionNode( build_fieldSel( new ExpressionNode( build_field_name_FLOATING_DECIMALconstant( *$1 ) ), maybeMoveBuild<Expression>( $2 ) ) ); }
+                { $$ = new ExpressionNode( build_fieldSel( yylloc, new ExpressionNode( build_field_name_FLOATING_DECIMALconstant( yylloc, *$1 ) ), maybeMoveBuild( $2 ) ) ); }
         | FLOATING_DECIMALconstant '[' field_name_list ']'
                 { $$ = new ExpressionNode( build_fieldSel( new ExpressionNode( build_field_name_FLOATING_DECIMALconstant( *$1 ) ), build_tuple( $3 ) ) ); }
+                { $$ = new ExpressionNode( build_fieldSel( yylloc, new ExpressionNode( build_field_name_FLOATING_DECIMALconstant( yylloc, *$1 ) ), build_tuple( yylloc, $3 ) ) ); }
         | field_name '.' field
                 { $$ = new ExpressionNode( build_fieldSel( $1, maybeMoveBuild<Expression>( $3 ) ) ); }
+                { $$ = new ExpressionNode( build_fieldSel( yylloc, $1, maybeMoveBuild( $3 ) ) ); }
         | field_name '.' '[' field_name_list ']'
                 { $$ = new ExpressionNode( build_fieldSel( $1, build_tuple( $4 ) ) ); }
+                { $$ = new ExpressionNode( build_fieldSel( yylloc, $1, build_tuple( yylloc, $4 ) ) ); }
         | field_name ARROW field
                 { $$ = new ExpressionNode( build_pfieldSel( $1, maybeMoveBuild<Expression>( $3 ) ) ); }
+                { $$ = new ExpressionNode( build_pfieldSel( yylloc, $1, maybeMoveBuild( $3 ) ) ); }
         | field_name ARROW '[' field_name_list ']'
                 { $$ = new ExpressionNode( build_pfieldSel( $1, build_tuple( $4 ) ) ); }
+                { $$ = new ExpressionNode( build_pfieldSel( yylloc, $1, build_tuple( yylloc, $4 ) ) ); }
+        ;
 field_name:
         INTEGERconstant fraction_constants_opt
                 { $$ = new ExpressionNode( build_field_name_fraction_constants( build_constantInteger( *$1 ), $2 ) ); }
+                { $$ = new ExpressionNode( build_field_name_fraction_constants( yylloc, build_constantInteger( yylloc, *$1 ), $2 ) ); }
         | FLOATINGconstant fraction_constants_opt
                 { $$ = new ExpressionNode( build_field_name_fraction_constants( build_field_name_FLOATINGconstant( *$1 ), $2 ) ); }
+                { $$ = new ExpressionNode( build_field_name_fraction_constants( yylloc, build_field_name_FLOATINGconstant( yylloc, *$1 ), $2 ) ); }
         | identifier_at fraction_constants_opt                          // CFA, allow anonymous fields
+                {
                         $$ = new ExpressionNode( build_field_name_fraction_constants( build_varref( $1 ), $2 ) );
+                        $$ = new ExpressionNode( build_field_name_fraction_constants( yylloc, build_varref( yylloc, $1 ), $2 ) );
+                }
+        ;
 …
         | fraction_constants_opt FLOATING_FRACTIONconstant
+                {
                         Expression * constant = build_field_name_FLOATING_FRACTIONconstant( *$2 );
                         $$ = $1 != nullptr ? new ExpressionNode( build_fieldSel( $1,  constant ) ) : new ExpressionNode( constant );
+                        ast::Expr * constant = build_field_name_FLOATING_FRACTIONconstant( yylloc, *$2 );
+                        $$ = $1 != nullptr ? new ExpressionNode( build_fieldSel( yylloc, $1, constant ) ) : new ExpressionNode( constant );
+                }
+        ;
 …
         | constant
         | string_literal
                 { $$ = new ExpressionNode( $1 ); }
+                { $$ = $1; }
         | EXTENSION cast_expression                                                     // GCC
                 { $$ = $2->set_extension( true ); }
 …
+                {
                         switch ( $1 ) {
                           case OperKinds::AddressOf:
                                 $$ = new ExpressionNode( new AddressExpr( maybeMoveBuild<Expression>( $2 ) ) );
+                        case OperKinds::AddressOf:
+                                $$ = new ExpressionNode( new ast::AddressExpr( maybeMoveBuild( $2 ) ) );
                                 break;
                           case OperKinds::PointTo:
                                 $$ = new ExpressionNode( build_unary_val( $1, $2 ) );
+                        case OperKinds::PointTo:
+                                $$ = new ExpressionNode( build_unary_val( yylloc, $1, $2 ) );
                                 break;
                           case OperKinds::And:
                                 $$ = new ExpressionNode( new AddressExpr( new AddressExpr( maybeMoveBuild<Expression>( $2 ) ) ) );
+                        case OperKinds::And:
+                                $$ = new ExpressionNode( new ast::AddressExpr( new ast::AddressExpr( maybeMoveBuild( $2 ) ) ) );
                                 break;
                           default:
+                        default:
                                 assert( false );
+                        }
+                }
         | unary_operator cast_expression
                 { $$ = new ExpressionNode( build_unary_val( $1, $2 ) ); }
+                { $$ = new ExpressionNode( build_unary_val( yylloc, $1, $2 ) ); }
         | ICR unary_expression
                 { $$ = new ExpressionNode( build_unary_ptr( OperKinds::Incr, $2 ) ); }
+                { $$ = new ExpressionNode( build_unary_val( yylloc, OperKinds::Incr, $2 ) ); }
         | DECR unary_expression
                 { $$ = new ExpressionNode( build_unary_ptr( OperKinds::Decr, $2 ) ); }
+                { $$ = new ExpressionNode( build_unary_val( yylloc, OperKinds::Decr, $2 ) ); }
         | SIZEOF unary_expression
                 { $$ = new ExpressionNode( new SizeofExpr( maybeMoveBuild<Expression>( $2 ) ) ); }
+                { $$ = new ExpressionNode( new ast::SizeofExpr( yylloc, maybeMoveBuild( $2 ) ) ); }
         | SIZEOF '(' type_no_function ')'
                 { $$ = new ExpressionNode( new SizeofExpr( maybeMoveBuildType( $3 ) ) ); }
+                { $$ = new ExpressionNode( new ast::SizeofExpr( yylloc, maybeMoveBuildType( $3 ) ) ); }
         | ALIGNOF unary_expression                                                      // GCC, variable alignment
                 { $$ = new ExpressionNode( new AlignofExpr( maybeMoveBuild<Expression>( $2 ) ) ); }
+                { $$ = new ExpressionNode( new ast::AlignofExpr( yylloc, maybeMoveBuild( $2 ) ) ); }
         | ALIGNOF '(' type_no_function ')'                                      // GCC, type alignment
                 { $$ = new ExpressionNode( new AlignofExpr( maybeMoveBuildType( $3 ) ) ); }
+                { $$ = new ExpressionNode( new ast::AlignofExpr( yylloc, maybeMoveBuildType( $3 ) ) ); }
         | OFFSETOF '(' type_no_function ',' identifier ')'
                 { $$ = new ExpressionNode( build_offsetOf( $3, build_varref( $5 ) ) ); }
+                { $$ = new ExpressionNode( build_offsetOf( yylloc, $3, build_varref( yylloc, $5 ) ) ); }
         | TYPEID '(' type_no_function ')'
+                {
 …
         unary_expression
         | '(' type_no_function ')' cast_expression
                 { $$ = new ExpressionNode( build_cast( $2, $4 ) ); }
+                { $$ = new ExpressionNode( build_cast( yylloc, $2, $4 ) ); }
         | '(' aggregate_control '&' ')' cast_expression         // CFA
                 { $$ = new ExpressionNode( build_keyword_cast( $2, $5 ) ); }
+                { $$ = new ExpressionNode( build_keyword_cast( yylloc, $2, $5 ) ); }
         | '(' aggregate_control '*' ')' cast_expression         // CFA
                 { $$ = new ExpressionNode( build_keyword_cast( $2, $5 ) ); }
+                { $$ = new ExpressionNode( build_keyword_cast( yylloc, $2, $5 ) ); }
         | '(' VIRTUAL ')' cast_expression                                       // CFA
                 { $$ = new ExpressionNode( new VirtualCastExpr( maybeMoveBuild<Expression>( $4 ), maybeMoveBuildType( nullptr ) ) ); }
+                { $$ = new ExpressionNode( new ast::VirtualCastExpr( yylloc, maybeMoveBuild( $4 ), maybeMoveBuildType( nullptr ) ) ); }
         | '(' VIRTUAL type_no_function ')' cast_expression      // CFA
                 { $$ = new ExpressionNode( new VirtualCastExpr( maybeMoveBuild<Expression>( $5 ), maybeMoveBuildType( $3 ) ) ); }
+                { $$ = new ExpressionNode( new ast::VirtualCastExpr( yylloc, maybeMoveBuild( $5 ), maybeMoveBuildType( $3 ) ) ); }
         | '(' RETURN type_no_function ')' cast_expression       // CFA
                 { $$ = new ExpressionNode( build_cast( $3, $5, CastExpr::Return ) ); }
+                { $$ = new ExpressionNode( build_cast( yylloc, $3, $5, ast::CastExpr::Return ) ); }
         | '(' COERCE type_no_function ')' cast_expression       // CFA
                 { SemanticError( yylloc, "Coerce cast is currently unimplemented." ); $$ = nullptr; }
 …
                 { SemanticError( yylloc, "Qualifier cast is currently unimplemented." ); $$ = nullptr; }
 //      | '(' type_no_function ')' tuple
 //              { $$ = new ExpressionNode( build_cast( $2, $4 ) ); }
+//              { $$ = new ast::ExpressionNode( build_cast( yylloc, $2, $4 ) ); }
+        ;
 …
         cast_expression
         | exponential_expression '\\' cast_expression
                 { $$ = new ExpressionNode( build_binary_val( OperKinds::Exp, $1, $3 ) ); }
+                { $$ = new ExpressionNode( build_binary_val( yylloc, OperKinds::Exp, $1, $3 ) ); }
+        ;
 …
         exponential_expression
         | multiplicative_expression '*' exponential_expression
                 { $$ = new ExpressionNode( build_binary_val( OperKinds::Mul, $1, $3 ) ); }
+                { $$ = new ExpressionNode( build_binary_val( yylloc, OperKinds::Mul, $1, $3 ) ); }
         | multiplicative_expression '/' exponential_expression
                 { $$ = new ExpressionNode( build_binary_val( OperKinds::Div, $1, $3 ) ); }
+                { $$ = new ExpressionNode( build_binary_val( yylloc, OperKinds::Div, $1, $3 ) ); }
         | multiplicative_expression '%' exponential_expression
                 { $$ = new ExpressionNode( build_binary_val( OperKinds::Mod, $1, $3 ) ); }
+                { $$ = new ExpressionNode( build_binary_val( yylloc, OperKinds::Mod, $1, $3 ) ); }
+        ;
 …
         multiplicative_expression
         | additive_expression '+' multiplicative_expression
                 { $$ = new ExpressionNode( build_binary_val( OperKinds::Plus, $1, $3 ) ); }
+                { $$ = new ExpressionNode( build_binary_val( yylloc, OperKinds::Plus, $1, $3 ) ); }
         | additive_expression '-' multiplicative_expression
                 { $$ = new ExpressionNode( build_binary_val( OperKinds::Minus, $1, $3 ) ); }
+                { $$ = new ExpressionNode( build_binary_val( yylloc, OperKinds::Minus, $1, $3 ) ); }
+        ;
 …
         additive_expression
         | shift_expression LS additive_expression
                 { $$ = new ExpressionNode( build_binary_val( OperKinds::LShift, $1, $3 ) ); }
+                { $$ = new ExpressionNode( build_binary_val( yylloc, OperKinds::LShift, $1, $3 ) ); }
         | shift_expression RS additive_expression
                 { $$ = new ExpressionNode( build_binary_val( OperKinds::RShift, $1, $3 ) ); }
+                { $$ = new ExpressionNode( build_binary_val( yylloc, OperKinds::RShift, $1, $3 ) ); }
+        ;
 …
         shift_expression
         | relational_expression '<' shift_expression
                 { $$ = new ExpressionNode( build_binary_val( OperKinds::LThan, $1, $3 ) ); }
+                { $$ = new ExpressionNode( build_binary_val( yylloc, OperKinds::LThan, $1, $3 ) ); }
         | relational_expression '>' shift_expression
                 { $$ = new ExpressionNode( build_binary_val( OperKinds::GThan, $1, $3 ) ); }
+                { $$ = new ExpressionNode( build_binary_val( yylloc, OperKinds::GThan, $1, $3 ) ); }
         | relational_expression LE shift_expression
                 { $$ = new ExpressionNode( build_binary_val( OperKinds::LEThan, $1, $3 ) ); }
+                { $$ = new ExpressionNode( build_binary_val( yylloc, OperKinds::LEThan, $1, $3 ) ); }
         | relational_expression GE shift_expression
                 { $$ = new ExpressionNode( build_binary_val( OperKinds::GEThan, $1, $3 ) ); }
+                { $$ = new ExpressionNode( build_binary_val( yylloc, OperKinds::GEThan, $1, $3 ) ); }
+        ;
 …
         relational_expression
         | equality_expression EQ relational_expression
                 { $$ = new ExpressionNode( build_binary_val( OperKinds::Eq, $1, $3 ) ); }
+                { $$ = new ExpressionNode( build_binary_val( yylloc, OperKinds::Eq, $1, $3 ) ); }
         | equality_expression NE relational_expression
                 { $$ = new ExpressionNode( build_binary_val( OperKinds::Neq, $1, $3 ) ); }
+                { $$ = new ExpressionNode( build_binary_val( yylloc, OperKinds::Neq, $1, $3 ) ); }
+        ;
 …
         equality_expression
         | AND_expression '&' equality_expression
                 { $$ = new ExpressionNode( build_binary_val( OperKinds::BitAnd, $1, $3 ) ); }
+                { $$ = new ExpressionNode( build_binary_val( yylloc, OperKinds::BitAnd, $1, $3 ) ); }
+        ;
 …
         AND_expression
         | exclusive_OR_expression '^' AND_expression
                 { $$ = new ExpressionNode( build_binary_val( OperKinds::Xor, $1, $3 ) ); }
+                { $$ = new ExpressionNode( build_binary_val( yylloc, OperKinds::Xor, $1, $3 ) ); }
+        ;
 …
         exclusive_OR_expression
         | inclusive_OR_expression '|' exclusive_OR_expression
                 { $$ = new ExpressionNode( build_binary_val( OperKinds::BitOr, $1, $3 ) ); }
+                { $$ = new ExpressionNode( build_binary_val( yylloc, OperKinds::BitOr, $1, $3 ) ); }
+        ;
 …
         inclusive_OR_expression
         | logical_AND_expression ANDAND inclusive_OR_expression
                 { $$ = new ExpressionNode( build_and_or( $1, $3, true ) ); }
+                { $$ = new ExpressionNode( build_and_or( yylloc, $1, $3, ast::AndExpr ) ); }
+        ;
 …
         logical_AND_expression
         | logical_OR_expression OROR logical_AND_expression
                 { $$ = new ExpressionNode( build_and_or( $1, $3, false ) ); }
+                { $$ = new ExpressionNode( build_and_or( yylloc, $1, $3, ast::OrExpr ) ); }
+        ;
 …
         logical_OR_expression
         | logical_OR_expression '?' comma_expression ':' conditional_expression
                 { $$ = new ExpressionNode( build_cond( $1, $3, $5 ) ); }
+                { $$ = new ExpressionNode( build_cond( yylloc, $1, $3, $5 ) ); }
                 // FIX ME: computes $1 twice
         | logical_OR_expression '?' /* empty */ ':' conditional_expression // GCC, omitted first operand
                 { $$ = new ExpressionNode( build_cond( $1, $1, $4 ) ); }
+                { $$ = new ExpressionNode( build_cond( yylloc, $1, $1, $4 ) ); }
+        ;
 …
 //                              SemanticError( yylloc, "C @= assignment is currently unimplemented." ); $$ = nullptr;
 //                      } else {
                                 $$ = new ExpressionNode( build_binary_val( $2, $1, $3 ) );
+                                $$ = new ExpressionNode( build_binary_val( yylloc, $2, $1, $3 ) );
 //                      } // if
+                }
 …
 //              { $$ = new ExpressionNode( build_tuple( $3 ) ); }
         '[' ',' tuple_expression_list ']'
                 { $$ = new ExpressionNode( build_tuple( (ExpressionNode *)(new ExpressionNode( nullptr ) )->set_last( $3 ) ) ); }
+                { $$ = new ExpressionNode( build_tuple( yylloc, (ExpressionNode *)(new ExpressionNode( nullptr ) )->set_last( $3 ) ) ); }
         | '[' push assignment_expression pop ',' tuple_expression_list ']'
                 { $$ = new ExpressionNode( build_tuple( (ExpressionNode *)($3->set_last( $6 ) ) )); }
+                { $$ = new ExpressionNode( build_tuple( yylloc, (ExpressionNode *)($3->set_last( $6 ) ) )); }
+        ;
 …
         assignment_expression
         | comma_expression ',' assignment_expression
                 { $$ = new ExpressionNode( new CommaExpr( maybeMoveBuild<Expression>( $1 ), maybeMoveBuild<Expression>( $3 ) ) ); }
+                { $$ = new ExpressionNode( new ast::CommaExpr( yylloc, maybeMoveBuild( $1 ), maybeMoveBuild( $3 ) ) ); }
+        ;
 …
         | mutex_statement
         | waitfor_statement
+        | waituntil_statement
         | exception_statement
         | enable_disable_statement
 …
         | asm_statement
         | DIRECTIVE
                 { $$ = new StatementNode( build_directive( $1 ) ); }
+                { $$ = new StatementNode( build_directive( yylloc, $1 ) ); }
+        ;
 …
                 // labels cannot be identifiers 0 or 1
         identifier_or_type_name ':' attribute_list_opt statement
                 { $$ = $4->add_label( $1, $3 ); }
+                { $$ = $4->add_label( yylloc, $1, $3 ); }
         | identifier_or_type_name ':' attribute_list_opt error // syntax error
+                {
 …
 compound_statement:
         '{' '}'
                 { $$ = new StatementNode( build_compound( (StatementNode *)0 ) ); }
+                { $$ = new StatementNode( build_compound( yylloc, (StatementNode *)0 ) ); }
         | '{' push
           local_label_declaration_opt                                           // GCC, local labels appear at start of block
           statement_decl_list                                                           // C99, intermix declarations and statements
           pop '}'
                 { $$ = new StatementNode( build_compound( $4 ) ); }
+                { $$ = new StatementNode( build_compound( yylloc, $4 ) ); }
+        ;
 …
 expression_statement:
         comma_expression_opt ';'
+                { $$ = new StatementNode( build_expr( $1 ) ); }
+        | MUTEX '(' ')' comma_expression ';'
+                { $$ = new StatementNode( build_mutex( nullptr, new StatementNode( build_expr( $4 ) ) ) ); }
+                { $$ = new StatementNode( build_expr( yylloc, $1 ) ); }
+        ;
 …
                 { $$ = $2; }
         | SWITCH '(' comma_expression ')' case_clause
                 { $$ = new StatementNode( build_switch( true, $3, $5 ) ); }
+                { $$ = new StatementNode( build_switch( yylloc, true, $3, $5 ) ); }
         | SWITCH '(' comma_expression ')' '{' push declaration_list_opt switch_clause_list_opt pop '}' // CFA
+                {
                         StatementNode *sw = new StatementNode( build_switch( true, $3, $8 ) );
+                        StatementNode *sw = new StatementNode( build_switch( yylloc, true, $3, $8 ) );
                         // The semantics of the declaration list is changed to include associated initialization, which is performed
                         // *before* the transfer to the appropriate case clause by hoisting the declarations into a compound
 …
                         // therefore, are removed from the grammar even though C allows it. The change also applies to choose
                         // statement.
                         $$ = $7 ? new StatementNode( build_compound( (StatementNode *)((new StatementNode( $7 ))->set_last( sw )) ) ) : sw;
+                        $$ = $7 ? new StatementNode( build_compound( yylloc, (StatementNode *)((new StatementNode( $7 ))->set_last( sw )) ) ) : sw;
+                }
         | SWITCH '(' comma_expression ')' '{' error '}'         // CFA, syntax error
                 { SemanticError( yylloc, "Only declarations can appear before the list of case clauses." ); $$ = nullptr; }
         | CHOOSE '(' comma_expression ')' case_clause           // CFA
                 { $$ = new StatementNode( build_switch( false, $3, $5 ) ); }
+                { $$ = new StatementNode( build_switch( yylloc, false, $3, $5 ) ); }
         | CHOOSE '(' comma_expression ')' '{' push declaration_list_opt switch_clause_list_opt pop '}' // CFA
+                {
                         StatementNode *sw = new StatementNode( build_switch( false, $3, $8 ) );
                         $$ = $7 ? new StatementNode( build_compound( (StatementNode *)((new StatementNode( $7 ))->set_last( sw )) ) ) : sw;
+                        StatementNode *sw = new StatementNode( build_switch( yylloc, false, $3, $8 ) );
+                        $$ = $7 ? new StatementNode( build_compound( yylloc, (StatementNode *)((new StatementNode( $7 ))->set_last( sw )) ) ) : sw;
+                }
         | CHOOSE '(' comma_expression ')' '{' error '}'         // CFA, syntax error
 …
         IF '(' conditional_declaration ')' statement            %prec THEN
                 // explicitly deal with the shift/reduce conflict on if/else
                 { $$ = new StatementNode( build_if( $3, maybe_build_compound( $5 ), nullptr ) ); }
+                { $$ = new StatementNode( build_if( yylloc, $3, maybe_build_compound( yylloc, $5 ), nullptr ) ); }
         | IF '(' conditional_declaration ')' statement ELSE statement
                 { $$ = new StatementNode( build_if( $3, maybe_build_compound( $5 ), maybe_build_compound( $7 ) ) ); }
+                { $$ = new StatementNode( build_if( yylloc, $3, maybe_build_compound( yylloc, $5 ), maybe_build_compound( yylloc, $7 ) ) ); }
+        ;
 …
         | declaration comma_expression                                          // semi-colon separated
                 { $$ = new CondCtl( $1, $2 ); }
+        ;
+        ;
 // CASE and DEFAULT clauses are only allowed in the SWITCH statement, precluding Duff's device. In addition, a case
 …
         constant_expression                                                     { $$ = $1; }
         | constant_expression ELLIPSIS constant_expression      // GCC, subrange
                 { $$ = new ExpressionNode( new RangeExpr( maybeMoveBuild<Expression>( $1 ), maybeMoveBuild<Expression>( $3 ) ) ); }
+                { $$ = new ExpressionNode( new ast::RangeExpr( yylloc, maybeMoveBuild( $1 ), maybeMoveBuild( $3 ) ) ); }
         | subrange                                                                                      // CFA, subrange
+        ;
 case_value_list:                                                                                // CFA
         case_value                                                                      { $$ = new StatementNode( build_case( $1 ) ); }
+        case_value                                                                      { $$ = new ClauseNode( build_case( yylloc, $1 ) ); }
                 // convert case list, e.g., "case 1, 3, 5:" into "case 1: case 3: case 5"
         | case_value_list ',' case_value                        { $$ = (StatementNode *)($1->set_last( new StatementNode( build_case( $3 ) ) ) ); }
+        | case_value_list ',' case_value                        { $$ = $1->set_last( new ClauseNode( build_case( yylloc, $3 ) ) ); }
+        ;
 …
         | CASE case_value_list error                                            // syntax error
                 { SemanticError( yylloc, "Missing colon after case list." ); $$ = nullptr; }
         | DEFAULT ':'                                                           { $$ = new StatementNode( build_default() ); }
+        | DEFAULT ':'                                                           { $$ = new ClauseNode( build_default( yylloc ) ); }
                 // A semantic check is required to ensure only one default clause per switch/choose statement.
         | DEFAULT error                                                                         //  syntax error
 …
 case_label_list:                                                                                // CFA
         case_label
         | case_label_list case_label                            { $$ = (StatementNode *)( $1->set_last( $2 )); }
+        | case_label_list case_label                            { $$ = $1->set_last( $2 ); }
+        ;
 case_clause:                                                                                    // CFA
         case_label_list statement                                       { $$ = $1->append_last_case( maybe_build_compound( $2 ) ); }
+        case_label_list statement                                       { $$ = $1->append_last_case( maybe_build_compound( yylloc, $2 ) ); }
+        ;
 …
 switch_clause_list:                                                                             // CFA
         case_label_list statement_list_nodecl
                 { $$ = $1->append_last_case( new StatementNode( build_compound( $2 ) ) ); }
+                { $$ = $1->append_last_case( new StatementNode( build_compound( yylloc, $2 ) ) ); }
         | switch_clause_list case_label_list statement_list_nodecl
                 { $$ = (StatementNode *)( $1->set_last( $2->append_last_case( new StatementNode( build_compound( $3 ) ) ) ) ); }
+                { $$ = $1->set_last( $2->append_last_case( new StatementNode( build_compound( yylloc, $3 ) ) ) ); }
+        ;
 iteration_statement:
         WHILE '(' ')' statement                                                         %prec THEN // CFA => while ( 1 )
                 { $$ = new StatementNode( build_while( new CondCtl( nullptr, NEW_ONE ), maybe_build_compound( $4 ) ) ); }
+                { $$ = new StatementNode( build_while( yylloc, new CondCtl( nullptr, NEW_ONE ), maybe_build_compound( yylloc, $4 ) ) ); }
         | WHILE '(' ')' statement ELSE statement                        // CFA
+                {
                         $$ = new StatementNode( build_while( new CondCtl( nullptr, NEW_ONE ), maybe_build_compound( $4 ) ) );
                         SemanticWarning( yylloc, Warning::SuperfluousElse, "" );
+                        $$ = new StatementNode( build_while( yylloc, new CondCtl( nullptr, NEW_ONE ), maybe_build_compound( yylloc, $4 ) ) );
+                        SemanticWarning( yylloc, Warning::SuperfluousElse );
+                }
         | WHILE '(' conditional_declaration ')' statement       %prec THEN
                 { $$ = new StatementNode( build_while( $3, maybe_build_compound( $5 ) ) ); }
+                { $$ = new StatementNode( build_while( yylloc, $3, maybe_build_compound( yylloc, $5 ) ) ); }
         | WHILE '(' conditional_declaration ')' statement ELSE statement // CFA
                 { $$ = new StatementNode( build_while( $3, maybe_build_compound( $5 ), $7 ) ); }
+                { $$ = new StatementNode( build_while( yylloc, $3, maybe_build_compound( yylloc, $5 ), $7 ) ); }
         | DO statement WHILE '(' ')' ';'                                        // CFA => do while( 1 )
                 { $$ = new StatementNode( build_do_while( NEW_ONE, maybe_build_compound( $2 ) ) ); }
+                { $$ = new StatementNode( build_do_while( yylloc, NEW_ONE, maybe_build_compound( yylloc, $2 ) ) ); }
         | DO statement WHILE '(' ')' ELSE statement                     // CFA
+                {
                         $$ = new StatementNode( build_do_while( NEW_ONE, maybe_build_compound( $2 ) ) );
                         SemanticWarning( yylloc, Warning::SuperfluousElse, "" );
+                        $$ = new StatementNode( build_do_while( yylloc, NEW_ONE, maybe_build_compound( yylloc, $2 ) ) );
+                        SemanticWarning( yylloc, Warning::SuperfluousElse );
+                }
         | DO statement WHILE '(' comma_expression ')' ';'
                 { $$ = new StatementNode( build_do_while( $5, maybe_build_compound( $2 ) ) ); }
+                { $$ = new StatementNode( build_do_while( yylloc, $5, maybe_build_compound( yylloc, $2 ) ) ); }
         | DO statement WHILE '(' comma_expression ')' ELSE statement // CFA
                 { $$ = new StatementNode( build_do_while( $5, maybe_build_compound( $2 ), $8 ) ); }
+                { $$ = new StatementNode( build_do_while( yylloc, $5, maybe_build_compound( yylloc, $2 ), $8 ) ); }
         | FOR '(' ')' statement                                                         %prec THEN // CFA => for ( ;; )
                 { $$ = new StatementNode( build_for( new ForCtrl( (ExpressionNode * )nullptr, (ExpressionNode * )nullptr, (ExpressionNode * )nullptr ), maybe_build_compound( $4 ) ) ); }
+                { $$ = new StatementNode( build_for( yylloc, new ForCtrl( nullptr, nullptr, nullptr ), maybe_build_compound( yylloc, $4 ) ) ); }
         | FOR '(' ')' statement ELSE statement                          // CFA
+                {
                         $$ = new StatementNode( build_for( new ForCtrl( (ExpressionNode * )nullptr, (ExpressionNode * )nullptr, (ExpressionNode * )nullptr ), maybe_build_compound( $4 ) ) );
                         SemanticWarning( yylloc, Warning::SuperfluousElse, "" );
+                        $$ = new StatementNode( build_for( yylloc, new ForCtrl( nullptr, nullptr, nullptr ), maybe_build_compound( yylloc, $4 ) ) );
+                        SemanticWarning( yylloc, Warning::SuperfluousElse );
+                }
         | FOR '(' for_control_expression_list ')' statement     %prec THEN
                 { $$ = new StatementNode( build_for( $3, maybe_build_compound( $5 ) ) ); }
+                { $$ = new StatementNode( build_for( yylloc, $3, maybe_build_compound( yylloc, $5 ) ) ); }
         | FOR '(' for_control_expression_list ')' statement ELSE statement // CFA
                 { $$ = new StatementNode( build_for( $3, maybe_build_compound( $5 ), $7 ) ); }
+                { $$ = new StatementNode( build_for( yylloc, $3, maybe_build_compound( yylloc, $5 ), $7 ) ); }
+        ;
 …
                         if ( $1->condition ) {
                                 if ( $3->condition ) {
                                         $1->condition->expr.reset( new LogicalExpr( $1->condition->expr.release(), $3->condition->expr.release(), true ) );
+                                        $1->condition->expr.reset( new ast::LogicalExpr( yylloc, $1->condition->expr.release(), $3->condition->expr.release(), ast::AndExpr ) );
                                 } // 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() ) );
+                                        $1->change->expr.reset( new ast::CommaExpr( yylloc, $1->change->expr.release(), $3->change->expr.release() ) );
                                 } // if
                         } else $1->change = $3->change;
 …
 for_control_expression:
         ';' comma_expression_opt ';' comma_expression_opt
                 { $$ = new ForCtrl( (ExpressionNode * )nullptr, $2, $4 ); }
+                { $$ = new ForCtrl( nullptr, $2, $4 ); }
         | comma_expression ';' comma_expression_opt ';' comma_expression_opt
+                { $$ = new ForCtrl( $1, $3, $5 ); }
+                {
+                        StatementNode * init = $1 ? new StatementNode( new ast::ExprStmt( yylloc, maybeMoveBuild( $1 ) ) ) : nullptr;
+                        $$ = new ForCtrl( init, $3, $5 );
+                }
         | declaration comma_expression_opt ';' comma_expression_opt // C99, declaration has ';'
                 { $$ = new ForCtrl( $1, $2, $4 ); }
+                { $$ = new ForCtrl( new StatementNode( $1 ), $2, $4 ); }
         | '@' ';' comma_expression                                                      // CFA, empty loop-index
                 { $$ = new ForCtrl( (ExpressionNode *)nullptr, $3, nullptr ); }
+                { $$ = new ForCtrl( nullptr, $3, nullptr ); }
         | '@' ';' comma_expression ';' comma_expression         // CFA, empty loop-index
                 { $$ = new ForCtrl( (ExpressionNode *)nullptr, $3, $5 ); }
+                { $$ = new ForCtrl( nullptr, $3, $5 ); }
         | comma_expression                                                                      // CFA, anonymous loop-index
                 { $$ = forCtrl( $1, new string( DeclarationNode::anonymous.newName() ), NEW_ZERO, OperKinds::LThan, $1->clone(), NEW_ONE ); }
+                { $$ = forCtrl( yylloc, $1, new string( DeclarationNode::anonymous.newName() ), NEW_ZERO, OperKinds::LThan, $1->clone(), NEW_ONE ); }
         | downupdowneq comma_expression                                         // CFA, anonymous loop-index
                 { $$ = forCtrl( $2, new string( DeclarationNode::anonymous.newName() ), UPDOWN( $1, NEW_ZERO, $2->clone() ), $1, UPDOWN( $1, $2->clone(), NEW_ZERO ), NEW_ONE ); }
+                { $$ = forCtrl( yylloc, $2, new string( DeclarationNode::anonymous.newName() ), UPDOWN( $1, NEW_ZERO, $2->clone() ), $1, UPDOWN( $1, $2->clone(), NEW_ZERO ), NEW_ONE ); }
         | comma_expression updowneq comma_expression            // CFA, anonymous loop-index
                 { $$ = forCtrl( $1, new string( DeclarationNode::anonymous.newName() ), UPDOWN( $2, $1->clone(), $3 ), $2, UPDOWN( $2, $3->clone(), $1->clone() ), NEW_ONE ); }
+                { $$ = forCtrl( yylloc, $1, new string( DeclarationNode::anonymous.newName() ), UPDOWN( $2, $1->clone(), $3 ), $2, UPDOWN( $2, $3->clone(), $1->clone() ), NEW_ONE ); }
         | '@' updowneq comma_expression                                         // CFA, anonymous loop-index
+                {
                         if ( $2 == OperKinds::LThan || $2 == OperKinds::LEThan ) { SemanticError( yylloc, MISSING_LOW ); $$ = nullptr; }
                         else $$ = forCtrl( $3, new string( DeclarationNode::anonymous.newName() ), $3->clone(), $2, nullptr, NEW_ONE );
+                        else $$ = forCtrl( yylloc, $3, new string( DeclarationNode::anonymous.newName() ), $3->clone(), $2, nullptr, NEW_ONE );
+                }
         | comma_expression updowneq '@'                                         // CFA, anonymous loop-index
 …
+                }
         | comma_expression updowneq comma_expression '~' comma_expression // CFA, anonymous loop-index
                 { $$ = forCtrl( $1, new string( DeclarationNode::anonymous.newName() ), UPDOWN( $2, $1->clone(), $3 ), $2, UPDOWN( $2, $3->clone(), $1->clone() ), $5 ); }
+                { $$ = forCtrl( yylloc, $1, new string( DeclarationNode::anonymous.newName() ), UPDOWN( $2, $1->clone(), $3 ), $2, UPDOWN( $2, $3->clone(), $1->clone() ), $5 ); }
         | '@' updowneq comma_expression '~' comma_expression // CFA, anonymous loop-index
+                {
                         if ( $2 == OperKinds::LThan || $2 == OperKinds::LEThan ) { SemanticError( yylloc, MISSING_LOW ); $$ = nullptr; }
                         else $$ = forCtrl( $3, new string( DeclarationNode::anonymous.newName() ), $3->clone(), $2, nullptr, $5 );
+                        else $$ = forCtrl( yylloc, $3, new string( DeclarationNode::anonymous.newName() ), $3->clone(), $2, nullptr, $5 );
+                }
         | comma_expression updowneq '@' '~' comma_expression // CFA, anonymous loop-index
 …
         | comma_expression ';' comma_expression                         // CFA
                 { $$ = forCtrl( $3, $1, NEW_ZERO, OperKinds::LThan, $3->clone(), NEW_ONE ); }
+                { $$ = forCtrl( yylloc, $3, $1, NEW_ZERO, OperKinds::LThan, $3->clone(), NEW_ONE ); }
         | comma_expression ';' downupdowneq comma_expression // CFA
                 { $$ = forCtrl( $4, $1, UPDOWN( $3, NEW_ZERO, $4->clone() ), $3, UPDOWN( $3, $4->clone(), NEW_ZERO ), NEW_ONE ); }
+                { $$ = forCtrl( yylloc, $4, $1, UPDOWN( $3, NEW_ZERO, $4->clone() ), $3, UPDOWN( $3, $4->clone(), NEW_ZERO ), NEW_ONE ); }
         | comma_expression ';' comma_expression updowneq comma_expression // CFA
                 { $$ = forCtrl( $3, $1, UPDOWN( $4, $3->clone(), $5 ), $4, UPDOWN( $4, $5->clone(), $3->clone() ), NEW_ONE ); }
+                { $$ = forCtrl( yylloc, $3, $1, UPDOWN( $4, $3->clone(), $5 ), $4, UPDOWN( $4, $5->clone(), $3->clone() ), NEW_ONE ); }
         | comma_expression ';' '@' updowneq comma_expression // CFA
+                {
                         if ( $4 == OperKinds::LThan || $4 == OperKinds::LEThan ) { SemanticError( yylloc, MISSING_LOW ); $$ = nullptr; }
                         else $$ = forCtrl( $5, $1, $5->clone(), $4, nullptr, NEW_ONE );
+                        else $$ = forCtrl( yylloc, $5, $1, $5->clone(), $4, nullptr, NEW_ONE );
+                }
         | comma_expression ';' comma_expression updowneq '@' // CFA
 …
                         if ( $4 == OperKinds::GThan || $4 == OperKinds::GEThan ) { SemanticError( yylloc, MISSING_HIGH ); $$ = nullptr; }
                         else if ( $4 == OperKinds::LEThan ) { SemanticError( yylloc, "Equality with missing high value is meaningless. Use \"~\"." ); $$ = nullptr; }
                         else $$ = forCtrl( $3, $1, $3->clone(), $4, nullptr, NEW_ONE );
+                        else $$ = forCtrl( yylloc, $3, $1, $3->clone(), $4, nullptr, NEW_ONE );
+                }
         | comma_expression ';' '@' updowneq '@'                         // CFA, error
 …
         | comma_expression ';' comma_expression updowneq comma_expression '~' comma_expression // CFA
                 { $$ = forCtrl( $3, $1, UPDOWN( $4, $3->clone(), $5 ), $4, UPDOWN( $4, $5->clone(), $3->clone() ), $7 ); }
+                { $$ = forCtrl( yylloc, $3, $1, UPDOWN( $4, $3->clone(), $5 ), $4, UPDOWN( $4, $5->clone(), $3->clone() ), $7 ); }
         | comma_expression ';' '@' updowneq comma_expression '~' comma_expression // CFA, error
+                {
                         if ( $4 == OperKinds::LThan || $4 == OperKinds::LEThan ) { SemanticError( yylloc, MISSING_LOW ); $$ = nullptr; }
                         else $$ = forCtrl( $5, $1, $5->clone(), $4, nullptr, $7 );
+                        else $$ = forCtrl( yylloc, $5, $1, $5->clone(), $4, nullptr, $7 );
+                }
         | comma_expression ';' comma_expression updowneq '@' '~' comma_expression // CFA
 …
                         if ( $4 == OperKinds::GThan || $4 == OperKinds::GEThan ) { SemanticError( yylloc, MISSING_HIGH ); $$ = nullptr; }
                         else if ( $4 == OperKinds::LEThan ) { SemanticError( yylloc, "Equality with missing high value is meaningless. Use \"~\"." ); $$ = nullptr; }
                         else $$ = forCtrl( $3, $1, $3->clone(), $4, nullptr, $7 );
+                        else $$ = forCtrl( yylloc, $3, $1, $3->clone(), $4, nullptr, $7 );
+                }
         | comma_expression ';' comma_expression updowneq comma_expression '~' '@' // CFA
                 { $$ = forCtrl( $3, $1, UPDOWN( $4, $3->clone(), $5 ), $4, UPDOWN( $4, $5->clone(), $3->clone() ), nullptr ); }
+                { $$ = forCtrl( yylloc, $3, $1, UPDOWN( $4, $3->clone(), $5 ), $4, UPDOWN( $4, $5->clone(), $3->clone() ), nullptr ); }
         | comma_expression ';' '@' updowneq comma_expression '~' '@' // CFA, error
+                {
                         if ( $4 == OperKinds::LThan || $4 == OperKinds::LEThan ) { SemanticError( yylloc, MISSING_LOW ); $$ = nullptr; }
                         else $$ = forCtrl( $5, $1, $5->clone(), $4, nullptr, nullptr );
+                        else $$ = forCtrl( yylloc, $5, $1, $5->clone(), $4, nullptr, nullptr );
+                }
         | comma_expression ';' comma_expression updowneq '@' '~' '@' // CFA
 …
                         if ( $4 == OperKinds::GThan || $4 == OperKinds::GEThan ) { SemanticError( yylloc, MISSING_HIGH ); $$ = nullptr; }
                         else if ( $4 == OperKinds::LEThan ) { SemanticError( yylloc, "Equality with missing high value is meaningless. Use \"~\"." ); $$ = nullptr; }
                         else $$ = forCtrl( $3, $1, $3->clone(), $4, nullptr, nullptr );
+                        else $$ = forCtrl( yylloc, $3, $1, $3->clone(), $4, nullptr, nullptr );
+                }
         | comma_expression ';' '@' updowneq '@' '~' '@' // CFA
 …
         | declaration comma_expression                                          // CFA
                 { $$ = forCtrl( $1, NEW_ZERO, OperKinds::LThan, $2, NEW_ONE ); }
+                { $$ = forCtrl( yylloc, $1, NEW_ZERO, OperKinds::LThan, $2, NEW_ONE ); }
         | declaration downupdowneq comma_expression                     // CFA
                 { $$ = forCtrl( $1, UPDOWN( $2, NEW_ZERO, $3 ), $2, UPDOWN( $2, $3->clone(), NEW_ZERO ), NEW_ONE ); }
+                { $$ = forCtrl( yylloc, $1, UPDOWN( $2, NEW_ZERO, $3 ), $2, UPDOWN( $2, $3->clone(), NEW_ZERO ), NEW_ONE ); }
         | declaration comma_expression updowneq comma_expression // CFA
                 { $$ = forCtrl( $1, UPDOWN( $3, $2->clone(), $4 ), $3, UPDOWN( $3, $4->clone(), $2->clone() ), NEW_ONE ); }
+                { $$ = forCtrl( yylloc, $1, UPDOWN( $3, $2->clone(), $4 ), $3, UPDOWN( $3, $4->clone(), $2->clone() ), NEW_ONE ); }
         | declaration '@' updowneq comma_expression                     // CFA
+                {
                         if ( $3 == OperKinds::LThan || $3 == OperKinds::LEThan ) { SemanticError( yylloc, MISSING_LOW ); $$ = nullptr; }
                         else $$ = forCtrl( $1, $4, $3, nullptr, NEW_ONE );
+                        else $$ = forCtrl( yylloc, $1, $4, $3, nullptr, NEW_ONE );
+                }
         | declaration comma_expression updowneq '@'                     // CFA
 …
                         if ( $3 == OperKinds::GThan || $3 == OperKinds::GEThan ) { SemanticError( yylloc, MISSING_HIGH ); $$ = nullptr; }
                         else if ( $3 == OperKinds::LEThan ) { SemanticError( yylloc, "Equality with missing high value is meaningless. Use \"~\"." ); $$ = nullptr; }
                         else $$ = forCtrl( $1, $2, $3, nullptr, NEW_ONE );
+                        else $$ = forCtrl( yylloc, $1, $2, $3, nullptr, NEW_ONE );
+                }
         | declaration comma_expression updowneq comma_expression '~' comma_expression // CFA
                 { $$ = forCtrl( $1, UPDOWN( $3, $2, $4 ), $3, UPDOWN( $3, $4->clone(), $2->clone() ), $6 ); }
+                { $$ = forCtrl( yylloc, $1, UPDOWN( $3, $2, $4 ), $3, UPDOWN( $3, $4->clone(), $2->clone() ), $6 ); }
         | declaration '@' updowneq comma_expression '~' comma_expression // CFA
+                {
                         if ( $3 == OperKinds::LThan || $3 == OperKinds::LEThan ) { SemanticError( yylloc, MISSING_LOW ); $$ = nullptr; }
                         else $$ = forCtrl( $1, $4, $3, nullptr, $6 );
+                        else $$ = forCtrl( yylloc, $1, $4, $3, nullptr, $6 );
+                }
         | declaration comma_expression updowneq '@' '~' comma_expression // CFA
 …
                         if ( $3 == OperKinds::GThan || $3 == OperKinds::GEThan ) { SemanticError( yylloc, MISSING_HIGH ); $$ = nullptr; }
                         else if ( $3 == OperKinds::LEThan ) { SemanticError( yylloc, "Equality with missing high value is meaningless. Use \"~\"." ); $$ = nullptr; }
                         else $$ = forCtrl( $1, $2, $3, nullptr, $6 );
+                        else $$ = forCtrl( yylloc, $1, $2, $3, nullptr, $6 );
+                }
         | declaration comma_expression updowneq comma_expression '~' '@' // CFA
                 { $$ = forCtrl( $1, UPDOWN( $3, $2, $4 ), $3, UPDOWN( $3, $4->clone(), $2->clone() ), nullptr ); }
+                { $$ = forCtrl( yylloc, $1, UPDOWN( $3, $2, $4 ), $3, UPDOWN( $3, $4->clone(), $2->clone() ), nullptr ); }
         | declaration '@' updowneq comma_expression '~' '@' // CFA
+                {
                         if ( $3 == OperKinds::LThan || $3 == OperKinds::LEThan ) { SemanticError( yylloc, MISSING_LOW ); $$ = nullptr; }
                         else $$ = forCtrl( $1, $4, $3, nullptr, nullptr );
+                        else $$ = forCtrl( yylloc, $1, $4, $3, nullptr, nullptr );
+                }
         | declaration comma_expression updowneq '@' '~' '@'     // CFA
 …
                         if ( $3 == OperKinds::GThan || $3 == OperKinds::GEThan ) { SemanticError( yylloc, MISSING_HIGH ); $$ = nullptr; }
                         else if ( $3 == OperKinds::LEThan ) { SemanticError( yylloc, "Equality with missing high value is meaningless. Use \"~\"." ); $$ = nullptr; }
                         else $$ = forCtrl( $1, $2, $3, nullptr, nullptr );
+                        else $$ = forCtrl( yylloc, $1, $2, $3, nullptr, nullptr );
+                }
         | declaration '@' updowneq '@' '~' '@'                          // CFA, error
 …
                         SemanticError( yylloc, "Type iterator is currently unimplemented." ); $$ = nullptr;
+                }
+        ;
+        ;
 downupdowneq:
 …
         | ErangeDownEq
                 { $$ = OperKinds::GEThan; }
+        ;
+        ;
 updown:
 …
         | ErangeDown
                 { $$ = OperKinds::GThan; }
+        ;
+        ;
 updowneq:
 …
         | ErangeDownEq
                 { $$ = OperKinds::GEThan; }
+        ;
+        ;
 jump_statement:
         GOTO identifier_or_type_name ';'
                 { $$ = new StatementNode( build_branch( $2, BranchStmt::Goto ) ); }
+                { $$ = new StatementNode( build_branch( yylloc, $2, ast::BranchStmt::Goto ) ); }
         | GOTO '*' comma_expression ';'                                         // GCC, computed goto
                 // The syntax for the GCC computed goto violates normal expression precedence, e.g., goto *i+3; => goto *(i+3);
 …
                 // A semantic check is required to ensure fallthru appears only in the body of a choose statement.
         | fall_through_name ';'                                                         // CFA
                 { $$ = new StatementNode( build_branch( BranchStmt::FallThrough ) ); }
+                { $$ = new StatementNode( build_branch( yylloc, ast::BranchStmt::FallThrough ) ); }
         | fall_through_name identifier_or_type_name ';'         // CFA
                 { $$ = new StatementNode( build_branch( $2, BranchStmt::FallThrough ) ); }
+                { $$ = new StatementNode( build_branch( yylloc, $2, ast::BranchStmt::FallThrough ) ); }
         | fall_through_name DEFAULT ';'                                         // CFA
                 { $$ = new StatementNode( build_branch( BranchStmt::FallThroughDefault ) ); }
+                { $$ = new StatementNode( build_branch( yylloc, ast::BranchStmt::FallThroughDefault ) ); }
         | CONTINUE ';'
                 // A semantic check is required to ensure this statement appears only in the body of an iteration statement.
                 { $$ = new StatementNode( build_branch( BranchStmt::Continue ) ); }
+                { $$ = new StatementNode( build_branch( yylloc, ast::BranchStmt::Continue ) ); }
         | CONTINUE identifier_or_type_name ';'                          // CFA, multi-level continue
                 // A semantic check is required to ensure this statement appears only in the body of an iteration statement, and
                 // the target of the transfer appears only at the start of an iteration statement.
                 { $$ = new StatementNode( build_branch( $2, BranchStmt::Continue ) ); }
+                { $$ = new StatementNode( build_branch( yylloc, $2, ast::BranchStmt::Continue ) ); }
         | BREAK ';'
                 // A semantic check is required to ensure this statement appears only in the body of an iteration statement.
                 { $$ = new StatementNode( build_branch( BranchStmt::Break ) ); }
+                { $$ = new StatementNode( build_branch( yylloc, ast::BranchStmt::Break ) ); }
         | BREAK identifier_or_type_name ';'                                     // CFA, multi-level exit
                 // A semantic check is required to ensure this statement appears only in the body of an iteration statement, and
                 // the target of the transfer appears only at the start of an iteration statement.
                 { $$ = new StatementNode( build_branch( $2, BranchStmt::Break ) ); }
+                { $$ = new StatementNode( build_branch( yylloc, $2, ast::BranchStmt::Break ) ); }
         | RETURN comma_expression_opt ';'
                 { $$ = new StatementNode( build_return( $2 ) ); }
+                { $$ = new StatementNode( build_return( yylloc, $2 ) ); }
         | RETURN '{' initializer_list_opt comma_opt '}' ';'
                 { SemanticError( yylloc, "Initializer return is currently unimplemented." ); $$ = nullptr; }
         | SUSPEND ';'
                 { $$ = new StatementNode( build_suspend( nullptr ) ); }
+                { $$ = new StatementNode( build_suspend( yylloc, nullptr, ast::SuspendStmt::None ) ); }
         | SUSPEND compound_statement
                 { $$ = new StatementNode( build_suspend( $2 ) ); }
+                { $$ = new StatementNode( build_suspend( yylloc, $2, ast::SuspendStmt::None ) ); }
         | SUSPEND COROUTINE ';'
                 { $$ = new StatementNode( build_suspend( nullptr, SuspendStmt::Coroutine ) ); }
+                { $$ = new StatementNode( build_suspend( yylloc, nullptr, ast::SuspendStmt::Coroutine ) ); }
         | SUSPEND COROUTINE compound_statement
                 { $$ = new StatementNode( build_suspend( $3, SuspendStmt::Coroutine ) ); }
+                { $$ = new StatementNode( build_suspend( yylloc, $3, ast::SuspendStmt::Coroutine ) ); }
         | SUSPEND GENERATOR ';'
                 { $$ = new StatementNode( build_suspend( nullptr, SuspendStmt::Generator ) ); }
+                { $$ = new StatementNode( build_suspend( yylloc, nullptr, ast::SuspendStmt::Generator ) ); }
         | SUSPEND GENERATOR compound_statement
                 { $$ = new StatementNode( build_suspend( $3, SuspendStmt::Generator ) ); }
+                { $$ = new StatementNode( build_suspend( yylloc, $3, ast::SuspendStmt::Generator ) ); }
         | THROW assignment_expression_opt ';'                           // handles rethrow
                 { $$ = new StatementNode( build_throw( $2 ) ); }
+                { $$ = new StatementNode( build_throw( yylloc, $2 ) ); }
         | THROWRESUME assignment_expression_opt ';'                     // handles reresume
                 { $$ = new StatementNode( build_resume( $2 ) ); }
+                { $$ = new StatementNode( build_resume( yylloc, $2 ) ); }
         | THROWRESUME assignment_expression_opt AT assignment_expression ';' // handles reresume
                 { $$ = new StatementNode( build_resume_at( $2, $4 ) ); }
 …
 with_statement:
         WITH '(' tuple_expression_list ')' statement
                 { $$ = new StatementNode( build_with( $3, $5 ) ); }
+        ;
 // If MUTEX becomes a general qualifier, there are shift/reduce conflicts, so change syntax to "with mutex".
+                { $$ = new StatementNode( build_with( yylloc, $3, $5 ) ); }
+        ;
+// If MUTEX becomes a general qualifier, there are shift/reduce conflicts, so possibly change syntax to "with mutex".
 mutex_statement:
+        MUTEX '(' argument_expression_list ')' statement
+                { $$ = new StatementNode( build_mutex( $3, $5 ) ); }
+        MUTEX '(' argument_expression_list_opt ')' statement
+                {
+                        if ( ! $3 ) { SemanticError( yylloc, "mutex argument list cannot be empty." ); $$ = nullptr; }
+                        $$ = new StatementNode( build_mutex( yylloc, $3, $5 ) );
+                }
+        ;
 …
                 { $$ = nullptr; }
         | when_clause
+        ;
-waitfor:
-        WAITFOR '(' cast_expression ')'
-                { $$ = $3; }
-//      | WAITFOR '(' cast_expression ',' argument_expression_list_opt ')'
-//              { $$ = (ExpressionNode *)$3->set_last( $5 ); }
-        | WAITFOR '(' cast_expression_list ':' argument_expression_list_opt ')'
-                { $$ = (ExpressionNode *)($3->set_last( $5 )); }
+        ;
 …
 timeout:
+        TIMEOUT '(' comma_expression ')'                        { $$ = $3; }
+        ;
+waitfor_clause:
+        TIMEOUT '(' comma_expression ')'                        { $$ = $3; }
+        ;
+wor:
+        OROR
+        | WOR
+waitfor:
+        WAITFOR '(' cast_expression ')'
+                { $$ = $3; }
+        | WAITFOR '(' cast_expression_list ':' argument_expression_list_opt ')'
+                { $$ = (ExpressionNode *)($3->set_last( $5 )); }
+        ;
+wor_waitfor_clause:
         when_clause_opt waitfor statement                                       %prec THEN
+                { $$ = build_waitfor( $2, maybe_build_compound( $3 ), $1 ); }
+        | when_clause_opt waitfor statement WOR waitfor_clause
+                { $$ = build_waitfor( $2, maybe_build_compound( $3 ), $1, $5 ); }
+        | when_clause_opt timeout statement                                     %prec THEN
+                { $$ = build_waitfor_timeout( $2, maybe_build_compound( $3 ), $1 ); }
+        | when_clause_opt ELSE statement
+                { $$ = build_waitfor_timeout( nullptr, maybe_build_compound( $3 ), $1 ); }
+                // Called first: create header for WaitForStmt.
+                { $$ = build_waitfor( yylloc, new ast::WaitForStmt( yylloc ), $1, $2, maybe_build_compound( yylloc, $3 ) ); }
+        | wor_waitfor_clause wor when_clause_opt waitfor statement
+                { $$ = build_waitfor( yylloc, $1, $3, $4, maybe_build_compound( yylloc, $5 ) ); }
+        | wor_waitfor_clause wor when_clause_opt ELSE statement
+                { $$ = build_waitfor_else( yylloc, $1, $3, maybe_build_compound( yylloc, $5 ) ); }
+        | wor_waitfor_clause wor when_clause_opt timeout statement      %prec THEN
+                { $$ = build_waitfor_timeout( yylloc, $1, $3, $4, maybe_build_compound( yylloc, $5 ) ); }
         // "else" must be conditional after timeout or timeout is never triggered (i.e., it is meaningless)
         | when_clause_opt timeout statement WOR ELSE statement // syntax error
+        | wor_waitfor_clause wor when_clause_opt timeout statement wor ELSE statement // syntax error
                 { SemanticError( yylloc, "else clause must be conditional after timeout or timeout never triggered." ); $$ = nullptr; }
         | when_clause_opt timeout statement WOR when_clause ELSE statement
                 { $$ = build_waitfor_timeout( $2, maybe_build_compound( $3 ), $1, maybe_build_compound( $7 ), $5 ); }
+        | wor_waitfor_clause wor when_clause_opt timeout statement wor when_clause ELSE statement
+                { $$ = build_waitfor_else( yylloc, build_waitfor_timeout( yylloc, $1, $3, $4, maybe_build_compound( yylloc, $5 ) ), $7, maybe_build_compound( yylloc, $9 ) ); }
+        ;
 waitfor_statement:
+        when_clause_opt waitfor statement                                       %prec THEN
+                { $$ = new StatementNode( build_waitfor( $2, $3, $1 ) ); }
+        | when_clause_opt waitfor statement WOR waitfor_clause
+                { $$ = new StatementNode( build_waitfor( $2, $3, $1, $5 ) ); }
+        wor_waitfor_clause                                                                      %prec THEN
+                { $$ = new StatementNode( $1 ); }
+        ;
+wand:
+        ANDAND
+        | WAND
+        ;
+waituntil:
+        WAITUNTIL '(' comma_expression ')'
+                { $$ = $3; }
+        ;
+waituntil_clause:
+        when_clause_opt waituntil statement
+                { $$ = build_waituntil_clause( yylloc, $1, $2, maybe_build_compound( yylloc, $3 ) ); }
+        | '(' wor_waituntil_clause ')'
+                { $$ = $2; }
+        ;
+wand_waituntil_clause:
+        waituntil_clause                                                                        %prec THEN
+                { $$ = $1; }
+        | waituntil_clause wand wand_waituntil_clause
+                { $$ = new ast::WaitUntilStmt::ClauseNode( ast::WaitUntilStmt::ClauseNode::Op::AND, $1, $3 ); }
+        ;
+wor_waituntil_clause:
+        wand_waituntil_clause
+                { $$ = $1; }
+        | wor_waituntil_clause wor wand_waituntil_clause
+                { $$ = new ast::WaitUntilStmt::ClauseNode( ast::WaitUntilStmt::ClauseNode::Op::OR, $1, $3 ); }
+        | wor_waituntil_clause wor when_clause_opt ELSE statement
+                { $$ = new ast::WaitUntilStmt::ClauseNode( ast::WaitUntilStmt::ClauseNode::Op::LEFT_OR, $1, build_waituntil_else( yylloc, $3, maybe_build_compound( yylloc, $5 ) ) ); }
+        | wor_waituntil_clause wor when_clause_opt timeout statement    %prec THEN
+                { $$ = new ast::WaitUntilStmt::ClauseNode( ast::WaitUntilStmt::ClauseNode::Op::LEFT_OR, $1, build_waituntil_timeout( yylloc, $3, $4, maybe_build_compound( yylloc, $5 ) ) ); }
+        // "else" must be conditional after timeout or timeout is never triggered (i.e., it is meaningless)
+        | wor_waituntil_clause wor when_clause_opt timeout statement wor ELSE statement // syntax error
+                { SemanticError( yylloc, "else clause must be conditional after timeout or timeout never triggered." ); $$ = nullptr; }
+        | wor_waituntil_clause wor when_clause_opt timeout statement wor when_clause ELSE statement
+                { $$ = new ast::WaitUntilStmt::ClauseNode( ast::WaitUntilStmt::ClauseNode::Op::LEFT_OR, $1,
+                new ast::WaitUntilStmt::ClauseNode( ast::WaitUntilStmt::ClauseNode::Op::OR,
+                    build_waituntil_timeout( yylloc, $3, $4, maybe_build_compound( yylloc, $5 ) ),
+                    build_waituntil_else( yylloc, $7, maybe_build_compound( yylloc, $9 ) ) ) ); }
+        ;
+waituntil_statement:
+        wor_waituntil_clause                                                            %prec THEN
+                // SKULLDUGGERY: create an empty compound statement to test parsing of waituntil statement.
+                {
+            $$ = new StatementNode( build_waituntil_stmt( yylloc, $1 ) );
+            // $$ = new StatementNode( build_compound( yylloc, nullptr ) );
+        }
+        ;
 exception_statement:
         TRY compound_statement handler_clause                                   %prec THEN
                 { $$ = new StatementNode( build_try( $2, $3, 0 ) ); }
+        TRY compound_statement handler_clause                                   %prec THEN
+                { $$ = new StatementNode( build_try( yylloc, $2, $3, nullptr ) ); }
         | TRY compound_statement finally_clause
                 { $$ = new StatementNode( build_try( $2, 0, $3 ) ); }
+                { $$ = new StatementNode( build_try( yylloc, $2, nullptr, $3 ) ); }
         | TRY compound_statement handler_clause finally_clause
                 { $$ = new StatementNode( build_try( $2, $3, $4 ) ); }
+                { $$ = new StatementNode( build_try( yylloc, $2, $3, $4 ) ); }
+        ;
 handler_clause:
         handler_key '(' push exception_declaration pop handler_predicate_opt ')' compound_statement
                 { $$ = new StatementNode( build_catch( $1, $4, $6, $8 ) ); }
+                { $$ = new ClauseNode( build_catch( yylloc, $1, $4, $6, $8 ) ); }
         | handler_clause handler_key '(' push exception_declaration pop handler_predicate_opt ')' compound_statement
                 { $$ = (StatementNode *)$1->set_last( new StatementNode( build_catch( $2, $5, $7, $9 ) ) ); }
+                { $$ = $1->set_last( new ClauseNode( build_catch( yylloc, $2, $5, $7, $9 ) ) ); }
+        ;
 …
 handler_key:
         CATCH                                                                           { $$ = CatchStmt::Terminate; }
         | RECOVER                                                                       { $$ = CatchStmt::Terminate; }
         | CATCHRESUME                                                           { $$ = CatchStmt::Resume; }
         | FIXUP                                                                         { $$ = CatchStmt::Resume; }
+        CATCH                                                                           { $$ = ast::Terminate; }
+        | RECOVER                                                                       { $$ = ast::Terminate; }
+        | CATCHRESUME                                                           { $$ = ast::Resume; }
+        | FIXUP                                                                         { $$ = ast::Resume; }
+        ;
 finally_clause:
         FINALLY compound_statement                                      { $$ = new StatementNode( build_finally( $2 ) ); }
+        FINALLY compound_statement                                      { $$ = new ClauseNode( build_finally( yylloc, $2 ) ); }
+        ;
 …
 asm_statement:
         ASM asm_volatile_opt '(' string_literal ')' ';'
                 { $$ = new StatementNode( build_asm( $2, $4, 0 ) ); }
+                { $$ = new StatementNode( build_asm( yylloc, $2, $4, nullptr ) ); }
         | ASM asm_volatile_opt '(' string_literal ':' asm_operands_opt ')' ';' // remaining GCC
                 { $$ = new StatementNode( build_asm( $2, $4, $6 ) ); }
+                { $$ = new StatementNode( build_asm( yylloc, $2, $4, $6 ) ); }
         | ASM asm_volatile_opt '(' string_literal ':' asm_operands_opt ':' asm_operands_opt ')' ';'
                 { $$ = new StatementNode( build_asm( $2, $4, $6, $8 ) ); }
+                { $$ = new StatementNode( build_asm( yylloc, $2, $4, $6, $8 ) ); }
         | ASM asm_volatile_opt '(' string_literal ':' asm_operands_opt ':' asm_operands_opt ':' asm_clobbers_list_opt ')' ';'
                 { $$ = new StatementNode( build_asm( $2, $4, $6, $8, $10 ) ); }
+                { $$ = new StatementNode( build_asm( yylloc, $2, $4, $6, $8, $10 ) ); }
         | ASM asm_volatile_opt GOTO '(' string_literal ':' ':' asm_operands_opt ':' asm_clobbers_list_opt ':' label_list ')' ';'
                 { $$ = new StatementNode( build_asm( $2, $5, 0, $8, $10, $12 ) ); }
+                { $$ = new StatementNode( build_asm( yylloc, $2, $5, nullptr, $8, $10, $12 ) ); }
+        ;
 …
 asm_operand:                                                                                    // GCC
         string_literal '(' constant_expression ')'
                 { $$ = new ExpressionNode( new AsmExpr( nullptr, $1, maybeMoveBuild<Expression>( $3 ) ) ); }
+                { $$ = new ExpressionNode( new ast::AsmExpr( yylloc, "", maybeMoveBuild( $1 ), maybeMoveBuild( $3 ) ) ); }
         | '[' IDENTIFIER ']' string_literal '(' constant_expression ')'
+                { $$ = new ExpressionNode( new AsmExpr( $2, $4, maybeMoveBuild<Expression>( $6 ) ) ); }
+                {
+                        $$ = new ExpressionNode( new ast::AsmExpr( yylloc, *$2.str, maybeMoveBuild( $4 ), maybeMoveBuild( $6 ) ) );
+                        delete $2.str;
+                }
+        ;
 …
                 { $$ = nullptr; }                                                               // use default argument
         | string_literal
                 { $$ = new ExpressionNode( $1 ); }
+                { $$ = $1; }
         | asm_clobbers_list_opt ',' string_literal
                 { $$ = (ExpressionNode *)($1->set_last( new ExpressionNode( $3 ) )); }
+                { $$ = (ExpressionNode *)( $1->set_last( $3 ) ); }
+        ;
 …
         identifier
+                {
                         $$ = new LabelNode(); $$->labels.push_back( *$1 );
+                        $$ = new LabelNode(); $$->labels.emplace_back( yylloc, *$1 );
                         delete $1;                                                                      // allocated by lexer
+                }
         | label_list ',' identifier
+                {
                         $$ = $1; $1->labels.push_back( *$3 );
+                        $$ = $1; $1->labels.emplace_back( yylloc, *$3 );
                         delete $3;                                                                      // allocated by lexer
+                }
 …
+                {
                         // printf( "C_DECLARATION1 %p %s\n", $$, $$->name ? $$->name->c_str() : "(nil)" );
                         // for ( Attribute * attr: reverseIterate( $$->attributes ) ) {
+                        // for ( Attribute * attr: reverseIterate( $$->attributes ) ) {
                         //   printf( "\tattr %s\n", attr->name.c_str() );
                         // } // for
 …
 static_assert:
         STATICASSERT '(' constant_expression ',' string_literal ')' ';' // C11
                 { $$ = DeclarationNode::newStaticAssert( $3, $5 ); }
+                { $$ = DeclarationNode::newStaticAssert( $3, maybeMoveBuild( $5 ) ); }
         | STATICASSERT '(' constant_expression ')' ';'          // CFA
                 { $$ = DeclarationNode::newStaticAssert( $3, build_constantStr( *new string( "\"\"" ) ) ); }
+                { $$ = DeclarationNode::newStaticAssert( $3, build_constantStr( yylloc, *new string( "\"\"" ) ) ); }
 // C declaration syntax is notoriously confusing and error prone. Cforall provides its own type, variable and function
 …
 //      '[' ']' identifier_or_type_name '(' push cfa_parameter_ellipsis_list_opt pop ')' // S/R conflict
 //              {
 //                      $$ = DeclarationNode::newFunction( $3, DeclarationNode::newTuple( 0 ), $6, 0, true );
+//                      $$ = DeclarationNode::newFunction( $3, DeclarationNode::newTuple( 0 ), $6, nullptr, true );
 //              }
 //      '[' ']' identifier '(' push cfa_parameter_ellipsis_list_opt pop ')'
 //              {
 //                      typedefTable.setNextIdentifier( *$5 );
 //                      $$ = DeclarationNode::newFunction( $5, DeclarationNode::newTuple( 0 ), $8, 0, true );
+//                      $$ = DeclarationNode::newFunction( $5, DeclarationNode::newTuple( 0 ), $8, nullptr, true );
 //              }
 //      | '[' ']' TYPEDEFname '(' push cfa_parameter_ellipsis_list_opt pop ')'
 //              {
 //                      typedefTable.setNextIdentifier( *$5 );
 //                      $$ = DeclarationNode::newFunction( $5, DeclarationNode::newTuple( 0 ), $8, 0, true );
+//                      $$ = DeclarationNode::newFunction( $5, DeclarationNode::newTuple( 0 ), $8, nullptr, true );
 //              }
 //      | '[' ']' typegen_name
 …
         cfa_abstract_tuple identifier_or_type_name '(' push cfa_parameter_ellipsis_list_opt pop ')' attribute_list_opt
                 // To obtain LR(1 ), this rule must be factored out from function return type (see cfa_abstract_declarator).
                 { $$ = DeclarationNode::newFunction( $2, $1, $5, 0 )->addQualifiers( $8 ); }
+                { $$ = DeclarationNode::newFunction( $2, $1, $5, nullptr )->addQualifiers( $8 ); }
         | cfa_function_return identifier_or_type_name '(' push cfa_parameter_ellipsis_list_opt pop ')' attribute_list_opt
                 { $$ = DeclarationNode::newFunction( $2, $1, $5, 0 )->addQualifiers( $8 ); }
+                { $$ = DeclarationNode::newFunction( $2, $1, $5, nullptr )->addQualifiers( $8 ); }
+        ;
 …
+                {
                         typedefTable.addToEnclosingScope( *$3->name, TYPEDEFname, "4" );
+                        $$ = $3->addType( $2 )->addTypedef();
+                        if ( $2->type->forall || ($2->type->kind == TypeData::Aggregate && $2->type->aggregate.params) ) {
+                                SemanticError( yylloc, "forall qualifier in typedef is currently unimplemented." ); $$ = nullptr;
+                        } else $$ = $3->addType( $2 )->addTypedef(); // watchout frees $2 and $3
+                }
         | typedef_declaration pop ',' push declarator
 …
+                }
         | type_qualifier_list TYPEDEF type_specifier declarator // remaining OBSOLESCENT (see 2 )
+                {
+                        typedefTable.addToEnclosingScope( *$4->name, TYPEDEFname, "6" );
+                        $$ = $4->addType( $3 )->addQualifiers( $1 )->addTypedef();
+                }
+                { SemanticError( yylloc, "Type qualifiers/specifiers before TYPEDEF is deprecated, move after TYPEDEF." ); $$ = nullptr; }
         | type_specifier TYPEDEF declarator
+                {
+                        typedefTable.addToEnclosingScope( *$3->name, TYPEDEFname, "7" );
+                        $$ = $3->addType( $1 )->addTypedef();
+                }
+                { SemanticError( yylloc, "Type qualifiers/specifiers before TYPEDEF is deprecated, move after TYPEDEF." ); $$ = nullptr; }
         | type_specifier TYPEDEF type_qualifier_list declarator
+                {
+                        typedefTable.addToEnclosingScope( *$4->name, TYPEDEFname, "8" );
+                        $$ = $4->addQualifiers( $1 )->addTypedef()->addType( $1 );
+                }
+                { SemanticError( yylloc, "Type qualifiers/specifiers before TYPEDEF is deprecated, move after TYPEDEF." ); $$ = nullptr; }
+        ;
 …
         TYPEDEF identifier '=' assignment_expression
+                {
                         SemanticError( yylloc, "Typedef expression is deprecated, use typeof(...) instead." ); $$ = nullptr;
+                        SemanticError( yylloc, "TYPEDEF expression is deprecated, use typeof(...) instead." ); $$ = nullptr;
+                }
         | typedef_expression pop ',' push identifier '=' assignment_expression
+                {
                         SemanticError( yylloc, "Typedef expression is deprecated, use typeof(...) instead." ); $$ = nullptr;
+                        SemanticError( yylloc, "TYPEDEF expression is deprecated, use typeof(...) instead." ); $$ = nullptr;
+                }
+        ;
 …
         | typedef_expression                                                            // deprecated GCC, naming expression type
         | sue_declaration_specifier
+                {
+                        assert( $1->type );
+                        if ( $1->type->qualifiers.any() ) {                     // CV qualifiers ?
+                                SemanticError( yylloc, "Useless type qualifier(s) in empty declaration." ); $$ = nullptr;
+                        }
+                        // enums are never empty declarations because there must have at least one enumeration.
+                        if ( $1->type->kind == TypeData::AggregateInst && $1->storageClasses.any() ) { // storage class ?
+                                SemanticError( yylloc, "Useless storage qualifier(s) in empty aggregate declaration." ); $$ = nullptr;
+                        }
+                }
+        ;
 …
                 // A semantic check is required to ensure asm_name only appears on declarations with implicit or explicit static
                 // storage-class
         declarator asm_name_opt initializer_opt
+        variable_declarator asm_name_opt initializer_opt
                 { $$ = $1->addAsmName( $2 )->addInitializer( $3 ); }
+        | variable_type_redeclarator asm_name_opt initializer_opt
+                { $$ = $1->addAsmName( $2 )->addInitializer( $3 ); }
+        | general_function_declarator asm_name_opt
+                { $$ = $1->addAsmName( $2 )->addInitializer( nullptr ); }
+        | general_function_declarator asm_name_opt '=' VOID
+                { $$ = $1->addAsmName( $2 )->addInitializer( new InitializerNode( true ) ); }
         | declaring_list ',' attribute_list_opt declarator asm_name_opt initializer_opt
                 { $$ = $1->appendList( $4->addQualifiers( $3 )->addAsmName( $5 )->addInitializer( $6 ) ); }
+        ;
+general_function_declarator:
+        function_type_redeclarator
+        | function_declarator
+        ;
 declaration_specifier:                                                                  // type specifier + storage class
         basic_declaration_specifier
+        | type_declaration_specifier
         | sue_declaration_specifier
+        | type_declaration_specifier
+        | sue_declaration_specifier invalid_types
+                {
+                        SemanticError( yylloc, ::toString( "Missing ';' after end of ",
+                                $1->type->enumeration.name ? "enum" : ast::AggregateDecl::aggrString( $1->type->aggregate.kind ),
+                                " declaration" ) );
+                        $$ = nullptr;
+                }
+        ;
+invalid_types:
+        aggregate_key
+        | basic_type_name
+        | indirect_type
+        ;
 …
         basic_type_specifier
         | sue_type_specifier
+                {
-                        // printf( "sue_type_specifier2 %p %s\n", $$, $$->type->aggregate.name ? $$->type->aggregate.name->c_str() : "(nil)" );
-                        // for ( Attribute * attr: reverseIterate( $$->attributes ) ) {
-                        //   printf( "\tattr %s\n", attr->name.c_str() );
-                        // } // for
+                }
         | type_type_specifier
+        ;
 …
                 { $$ = DeclarationNode::newTypeQualifier( Type::Atomic ); }
         | forall
+                { $$ = DeclarationNode::newForall( $1 ); }
+        ;
 forall:
         FORALL '(' type_parameter_list ')'                                      // CFA
                 { $$ = DeclarationNode::newForall( $3 ); }
+                { $$ = $3; }
+        ;
 …
                 { $$ = DeclarationNode::newTypeof( $3 ); }
         | BASETYPEOF '(' type ')'                                                       // CFA: basetypeof( x ) y;
                 { $$ = DeclarationNode::newTypeof( new ExpressionNode( new TypeExpr( maybeMoveBuildType( $3 ) ) ), true ); }
+                { $$ = DeclarationNode::newTypeof( new ExpressionNode( new ast::TypeExpr( yylloc, maybeMoveBuildType( $3 ) ) ), true ); }
         | BASETYPEOF '(' comma_expression ')'                           // CFA: basetypeof( a+b ) y;
                 { $$ = DeclarationNode::newTypeof( $3, true ); }
 …
+                {
                         // printf( "sue_declaration_specifier %p %s\n", $$, $$->type->aggregate.name ? $$->type->aggregate.name->c_str() : "(nil)" );
                         // for ( Attribute * attr: reverseIterate( $$->attributes ) ) {
+                        // for ( Attribute * attr: reverseIterate( $$->attributes ) ) {
                         //   printf( "\tattr %s\n", attr->name.c_str() );
                         // } // for
 …
+                {
                         // printf( "sue_type_specifier %p %s\n", $$, $$->type->aggregate.name ? $$->type->aggregate.name->c_str() : "(nil)" );
                         // for ( Attribute * attr: reverseIterate( $$->attributes ) ) {
+                        // for ( Attribute * attr: reverseIterate( $$->attributes ) ) {
                         //   printf( "\tattr %s\n", attr->name.c_str() );
                         // } // for
 …
+                {
                         // printf( "elaborated_type %p %s\n", $$, $$->type->aggregate.name ? $$->type->aggregate.name->c_str() : "(nil)" );
                         // for ( Attribute * attr: reverseIterate( $$->attributes ) ) {
+                        // for ( Attribute * attr: reverseIterate( $$->attributes ) ) {
                         //   printf( "\tattr %s\n", attr->name.c_str() );
                         // } // for
 …
           '{' field_declaration_list_opt '}' type_parameters_opt
+                {
-                        // printf( "aggregate_type1 %s\n", $3.str->c_str() );
-                        // if ( $2 )
-                        //      for ( Attribute * attr: reverseIterate( $2->attributes ) ) {
-                        //              printf( "copySpecifiers12 %s\n", attr->name.c_str() );
-                        //      } // for
                         $$ = DeclarationNode::newAggregate( $1, $3, $8, $6, true )->addQualifiers( $2 );
-                        // printf( "aggregate_type2 %p %s\n", $$, $$->type->aggregate.name ? $$->type->aggregate.name->c_str() : "(nil)" );
-                        // for ( Attribute * attr: reverseIterate( $$->attributes ) ) {
-                        //      printf( "aggregate_type3 %s\n", attr->name.c_str() );
-                        // } // for
+                }
         | aggregate_key attribute_list_opt TYPEDEFname          // unqualified type name
 …
           '{' field_declaration_list_opt '}' type_parameters_opt
+                {
-                        // printf( "AGG3\n" );
                         DeclarationNode::newFromTypedef( $3 );
                         $$ = DeclarationNode::newAggregate( $1, $3, $8, $6, true )->addQualifiers( $2 );
 …
           '{' field_declaration_list_opt '}' type_parameters_opt
+                {
-                        // printf( "AGG4\n" );
                         DeclarationNode::newFromTypeGen( $3, nullptr );
                         $$ = DeclarationNode::newAggregate( $1, $3, $8, $6, true )->addQualifiers( $2 );
 …
                         // switched to a TYPEGENname. Link any generic arguments from typegen_name to new generic declaration and
                         // delete newFromTypeGen.
+                        $$ = DeclarationNode::newAggregate( $1, $3->type->symbolic.name, $3->type->symbolic.actuals, nullptr, false )->addQualifiers( $2 );
+                        $3->type->symbolic.name = nullptr;
+                        $3->type->symbolic.actuals = nullptr;
+                        delete $3;
+                        if ( $3->type->kind == TypeData::SymbolicInst && ! $3->type->symbolic.isTypedef ) {
+                                $$ = $3->addQualifiers( $2 );
+                        } else {
+                                $$ = DeclarationNode::newAggregate( $1, $3->type->symbolic.name, $3->type->symbolic.actuals, nullptr, false )->addQualifiers( $2 );
+                                $3->type->symbolic.name = nullptr;                      // copied to $$
+                                $3->type->symbolic.actuals = nullptr;
+                                delete $3;
+                        }
+                }
+        ;
 …
 aggregate_data:
         STRUCT vtable_opt
                 { $$ = AggregateDecl::Struct; }
+                { $$ = ast::AggregateDecl::Struct; }
         | UNION
                 { $$ = AggregateDecl::Union; }
+                { $$ = ast::AggregateDecl::Union; }
         | EXCEPTION                                                                                     // CFA
                 { $$ = AggregateDecl::Exception; }
           //            { SemanticError( yylloc, "exception aggregate is currently unimplemented." ); $$ = AggregateDecl::NoAggregate; }
+                { $$ = ast::AggregateDecl::Exception; }
+          //            { SemanticError( yylloc, "exception aggregate is currently unimplemented." ); $$ = ast::AggregateDecl::NoAggregate; }
+        ;
 aggregate_control:                                                                              // CFA
         MONITOR
                 { $$ = AggregateDecl::Monitor; }
+                { $$ = ast::AggregateDecl::Monitor; }
         | MUTEX STRUCT
                 { $$ = AggregateDecl::Monitor; }
+                { $$ = ast::AggregateDecl::Monitor; }
         | GENERATOR
                 { $$ = AggregateDecl::Generator; }
+                { $$ = ast::AggregateDecl::Generator; }
         | MUTEX GENERATOR
+                { SemanticError( yylloc, "monitor generator is currently unimplemented." ); $$ = AggregateDecl::NoAggregate; }
+                {
+                        SemanticError( yylloc, "monitor generator is currently unimplemented." );
+                        $$ = ast::AggregateDecl::NoAggregate;
+                }
         | COROUTINE
                 { $$ = AggregateDecl::Coroutine; }
+                { $$ = ast::AggregateDecl::Coroutine; }
         | MUTEX COROUTINE
+                { SemanticError( yylloc, "monitor coroutine is currently unimplemented." ); $$ = AggregateDecl::NoAggregate; }
+                {
+                        SemanticError( yylloc, "monitor coroutine is currently unimplemented." );
+                        $$ = ast::AggregateDecl::NoAggregate;
+                }
         | THREAD
                 { $$ = AggregateDecl::Thread; }
+                { $$ = ast::AggregateDecl::Thread; }
         | MUTEX THREAD
+                { SemanticError( yylloc, "monitor thread is currently unimplemented." ); $$ = AggregateDecl::NoAggregate; }
+                {
+                        SemanticError( yylloc, "monitor thread is currently unimplemented." );
+                        $$ = ast::AggregateDecl::NoAggregate;
+                }
+        ;
 …
                         $$ = fieldDecl( $1, $2 );
                         // printf( "type_specifier2 %p %s\n", $$, $$->type->aggregate.name ? $$->type->aggregate.name->c_str() : "(nil)" );
                         // for ( Attribute * attr: reverseIterate( $$->attributes ) ) {
+                        // for ( Attribute * attr: reverseIterate( $$->attributes ) ) {
                         //   printf( "\tattr %s\n", attr->name.c_str() );
                         // } // for
 …
         | EXTENSION type_specifier field_declaring_list_opt ';' // GCC
                 { $$ = fieldDecl( $2, $3 ); distExt( $$ ); }
+        | STATIC type_specifier field_declaring_list_opt ';' // CFA
+                { SemanticError( yylloc, "STATIC aggregate field qualifier currently unimplemented." ); $$ = nullptr; }
         | INLINE type_specifier field_abstract_list_opt ';'     // CFA
+                {
 …
+                }
         | INLINE aggregate_control ';'                                          // CFA
                 { SemanticError( yylloc, "INLINE aggregate control currently unimplemented." ); $$ = nullptr; }
+                { SemanticError( yylloc, "INLINE aggregate control currently unimplemented." ); $$ = nullptr; }
         | typedef_declaration ';'                                                       // CFA
         | cfa_field_declaring_list ';'                                          // CFA, new style field declaration
 …
                 { $$ = $1->addBitfield( $2 ); }
         | variable_type_redeclarator bit_subrange_size_opt
+                // A semantic check is required to ensure bit_subrange only appears on integral types.
+                { $$ = $1->addBitfield( $2 ); }
+        | function_type_redeclarator bit_subrange_size_opt
                 // A semantic check is required to ensure bit_subrange only appears on integral types.
                 { $$ = $1->addBitfield( $2 ); }
 …
                 { $$ = DeclarationNode::newEnum( $3->name, $6, true, false, nullptr, $4 )->addQualifiers( $2 ); }
         | ENUM '(' cfa_abstract_parameter_declaration ')' attribute_list_opt '{' enumerator_list comma_opt '}'
+                {
                         if ( $3->storageClasses.val != 0 || $3->type->qualifiers.val != 0 )
+                {
+                        if ( $3->storageClasses.val != 0 || $3->type->qualifiers.any() )
                         { SemanticError( yylloc, "storage-class and CV qualifiers are not meaningful for enumeration constants, which are const." ); }
 …
         | ENUM '(' cfa_abstract_parameter_declaration ')' attribute_list_opt identifier attribute_list_opt
+                {
                         if ( $3->storageClasses.val != 0 || $3->type->qualifiers.val != 0 ) { SemanticError( yylloc, "storage-class and CV qualifiers are not meaningful for enumeration constants, which are const." ); }
+                        if ( $3->storageClasses.any() || $3->type->qualifiers.val != 0 ) { SemanticError( yylloc, "storage-class and CV qualifiers are not meaningful for enumeration constants, which are const." ); }
                         typedefTable.makeTypedef( *$6 );
+                }
 …
 enum_type_nobody:                                                                               // enum - {...}
         ENUM attribute_list_opt identifier
                 { typedefTable.makeTypedef( *$3 ); $$ = DeclarationNode::newEnum( $3, 0, false, false )->addQualifiers( $2 ); }
+                { typedefTable.makeTypedef( *$3 ); $$ = DeclarationNode::newEnum( $3, nullptr, false, false )->addQualifiers( $2 ); }
         | ENUM attribute_list_opt type_name
                 { typedefTable.makeTypedef( *$3->type->symbolic.name ); $$ = DeclarationNode::newEnum( $3->type->symbolic.name, 0, false, false )->addQualifiers( $2 ); }
+                { typedefTable.makeTypedef( *$3->type->symbolic.name ); $$ = DeclarationNode::newEnum( $3->type->symbolic.name, nullptr, false, false )->addQualifiers( $2 ); }
+        ;
 …
 type_no_function:                                                                               // sizeof, alignof, cast (constructor)
         cfa_abstract_declarator_tuple                                           // CFA
         | type_specifier
+        | type_specifier                                                                        // cannot be type_specifier_nobody, e.g., (struct S {}){} is a thing
         | type_specifier abstract_declarator
                 { $$ = $2->addType( $1 ); }
 …
         designator_list ':'                                                                     // C99, CFA uses ":" instead of "="
         | identifier_at ':'                                                                     // GCC, field name
                 { $$ = new ExpressionNode( build_varref( $1 ) ); }
+                { $$ = new ExpressionNode( build_varref( yylloc, $1 ) ); }
+        ;
 …
 designator:
         '.' identifier_at                                                                       // C99, field name
                 { $$ = new ExpressionNode( build_varref( $2 ) ); }
+                { $$ = new ExpressionNode( build_varref( yylloc, $2 ) ); }
         | '[' push assignment_expression pop ']'                        // C99, single array element
                 // assignment_expression used instead of constant_expression because of shift/reduce conflicts with tuple.
 …
                 { $$ = $3; }
         | '[' push constant_expression ELLIPSIS constant_expression pop ']' // GCC, multiple array elements
                 { $$ = new ExpressionNode( new RangeExpr( maybeMoveBuild<Expression>( $3 ), maybeMoveBuild<Expression>( $5 ) ) ); }
+                { $$ = new ExpressionNode( new ast::RangeExpr( yylloc, maybeMoveBuild( $3 ), maybeMoveBuild( $5 ) ) ); }
         | '.' '[' push field_name_list pop ']'                          // CFA, tuple field selector
                 { $$ = $4; }
 …
+                {
                         typedefTable.addToScope( *$2, TYPEDEFname, "9" );
                         if ( $1 == TypeDecl::Otype ) { SemanticError( yylloc, "otype keyword is deprecated, use T " ); }
                         if ( $1 == TypeDecl::Dtype ) { SemanticError( yylloc, "dtype keyword is deprecated, use T &" ); }
                         if ( $1 == TypeDecl::Ttype ) { SemanticError( yylloc, "ttype keyword is deprecated, use T ..." ); }
+                        if ( $1 == ast::TypeDecl::Otype ) { SemanticError( yylloc, "otype keyword is deprecated, use T " ); }
+                        if ( $1 == ast::TypeDecl::Dtype ) { SemanticError( yylloc, "dtype keyword is deprecated, use T &" ); }
+                        if ( $1 == ast::TypeDecl::Ttype ) { SemanticError( yylloc, "ttype keyword is deprecated, use T ..." ); }
+                }
           type_initializer_opt assertion_list_opt
 …
+                {
                         typedefTable.addToScope( *$2, TYPEDIMname, "9" );
                         $$ = DeclarationNode::newTypeParam( TypeDecl::Dimension, $2 );
+                        $$ = DeclarationNode::newTypeParam( ast::TypeDecl::Dimension, $2 );
+                }
         // | type_specifier identifier_parameter_declarator
         | assertion_list
                 { $$ = DeclarationNode::newTypeParam( TypeDecl::Dtype, new string( DeclarationNode::anonymous.newName() ) )->addAssertions( $1 ); }
+                { $$ = DeclarationNode::newTypeParam( ast::TypeDecl::Dtype, new string( DeclarationNode::anonymous.newName() ) )->addAssertions( $1 ); }
+        ;
 new_type_class:                                                                                 // CFA
         // empty
                 { $$ = TypeDecl::Otype; }
+                { $$ = ast::TypeDecl::Otype; }
         | '&'
                 { $$ = TypeDecl::Dtype; }
+                { $$ = ast::TypeDecl::Dtype; }
         | '*'
                 { $$ = TypeDecl::DStype; }                                              // dtype + sized
+                { $$ = ast::TypeDecl::DStype; }                                         // dtype + sized
         // | '(' '*' ')'
         //      { $$ = TypeDecl::Ftype; }
+        //      { $$ = ast::TypeDecl::Ftype; }
         | ELLIPSIS
                 { $$ = TypeDecl::Ttype; }
+                { $$ = ast::TypeDecl::Ttype; }
+        ;
 type_class:                                                                                             // CFA
         OTYPE
                 { $$ = TypeDecl::Otype; }
+                { $$ = ast::TypeDecl::Otype; }
         | DTYPE
                 { $$ = TypeDecl::Dtype; }
+                { $$ = ast::TypeDecl::Dtype; }
         | FTYPE
                 { $$ = TypeDecl::Ftype; }
+                { $$ = ast::TypeDecl::Ftype; }
         | TTYPE
                 { $$ = TypeDecl::Ttype; }
+                { $$ = ast::TypeDecl::Ttype; }
+        ;
 …
 type_list:                                                                                              // CFA
         type
                 { $$ = new ExpressionNode( new TypeExpr( maybeMoveBuildType( $1 ) ) ); }
+                { $$ = new ExpressionNode( new ast::TypeExpr( yylloc, maybeMoveBuildType( $1 ) ) ); }
         | assignment_expression
         | type_list ',' type
                 { $$ = (ExpressionNode *)($1->set_last( new ExpressionNode( new TypeExpr( maybeMoveBuildType( $3 ) ) ) )); }
+                { $$ = (ExpressionNode *)($1->set_last( new ExpressionNode( new ast::TypeExpr( yylloc, maybeMoveBuildType( $3 ) ) ) )); }
         | type_list ',' assignment_expression
                 { $$ = (ExpressionNode *)( $1->set_last( $3 )); }
 …
+                {
                         typedefTable.addToEnclosingScope( *$1, TYPEDEFname, "10" );
                         $$ = DeclarationNode::newTypeDecl( $1, 0 );
+                        $$ = DeclarationNode::newTypeDecl( $1, nullptr );
+                }
         | identifier_or_type_name '(' type_parameter_list ')'
 …
 trait_specifier:                                                                                // CFA
         TRAIT identifier_or_type_name '(' type_parameter_list ')' '{' '}'
+                { $$ = DeclarationNode::newTrait( $2, $4, 0 ); }
+                {
+                        SemanticWarning( yylloc, Warning::DeprecTraitSyntax );
+                        $$ = DeclarationNode::newTrait( $2, $4, nullptr );
+                }
+        | forall TRAIT identifier_or_type_name '{' '}'          // alternate
+                { $$ = DeclarationNode::newTrait( $3, $1, nullptr ); }
         | TRAIT identifier_or_type_name '(' type_parameter_list ')' '{' push trait_declaration_list pop '}'
+                { $$ = DeclarationNode::newTrait( $2, $4, $8 ); }
+                {
+                        SemanticWarning( yylloc, Warning::DeprecTraitSyntax );
+                        $$ = DeclarationNode::newTrait( $2, $4, $8 );
+                }
+        | forall TRAIT identifier_or_type_name '{' push trait_declaration_list pop '}' // alternate
+                { $$ = DeclarationNode::newTrait( $3, $1, $6 ); }
+        ;
 …
 external_definition:
         DIRECTIVE
                 { $$ = DeclarationNode::newDirectiveStmt( new StatementNode( build_directive( $1 ) ) ); }
+                { $$ = DeclarationNode::newDirectiveStmt( new StatementNode( build_directive( yylloc, $1 ) ) ); }
         | declaration
+                {
+                        // Variable declarations of anonymous types requires creating a unique type-name across multiple translation
+                        // unit, which is a dubious task, especially because C uses name rather than structural typing; hence it is
+                        // disallowed at the moment.
+                        if ( $1->linkage == ast::Linkage::Cforall && ! $1->storageClasses.is_static && $1->type && $1->type->kind == TypeData::AggregateInst ) {
+                                if ( $1->type->aggInst.aggregate->kind == TypeData::Enum && $1->type->aggInst.aggregate->enumeration.anon ) {
+                                        SemanticError( yylloc, "extern anonymous enumeration is currently unimplemented." ); $$ = nullptr;
+                                } else if ( $1->type->aggInst.aggregate->aggregate.anon ) { // handles struct or union
+                                        SemanticError( yylloc, "extern anonymous struct/union is currently unimplemented." ); $$ = nullptr;
+                                }
+                        }
+                }
         | IDENTIFIER IDENTIFIER
                 { IdentifierBeforeIdentifier( *$1.str, *$2.str, " declaration" ); $$ = nullptr; }
 …
+                }
         | ASM '(' string_literal ')' ';'                                        // GCC, global assembler statement
                 { $$ = DeclarationNode::newAsmStmt( new StatementNode( build_asm( false, $3, 0 ) ) ); }
+                { $$ = DeclarationNode::newAsmStmt( new StatementNode( build_asm( yylloc, false, $3, nullptr ) ) ); }
         | EXTERN STRINGliteral
+                {
                         linkageStack.push( linkage );                           // handle nested extern "C"/"Cforall"
                         linkage = LinkageSpec::update( yylloc, linkage, $2 );
+                        linkage = ast::Linkage::update( yylloc, linkage, $2 );
+                }
           up external_definition down
 …
+                {
                         linkageStack.push( linkage );                           // handle nested extern "C"/"Cforall"
                         linkage = LinkageSpec::update( yylloc, linkage, $2 );
+                        linkage = ast::Linkage::update( yylloc, linkage, $2 );
+                }
           '{' up external_definition_list_opt down '}'
 …
         | type_qualifier_list
+                {
                         if ( $1->type->qualifiers.val ) { SemanticError( yylloc, "CV qualifiers cannot be distributed; only storage-class and forall qualifiers." ); }
+                        if ( $1->type->qualifiers.any() ) { SemanticError( yylloc, "CV qualifiers cannot be distributed; only storage-class and forall qualifiers." ); }
                         if ( $1->type->forall ) forall = true;          // remember generic type
+                }
 …
+                {
                         distQual( $5, $1 );
                         forall = false;
+                        forall = false;
                         $$ = $5;
+                }
         | declaration_qualifier_list
+                {
                         if ( $1->type && $1->type->qualifiers.val ) { SemanticError( yylloc, "CV qualifiers cannot be distributed; only storage-class and forall qualifiers." ); }
+                        if ( $1->type && $1->type->qualifiers.any() ) { SemanticError( yylloc, "CV qualifiers cannot be distributed; only storage-class and forall qualifiers." ); }
                         if ( $1->type && $1->type->forall ) forall = true; // remember generic type
+                }
 …
+                {
                         distQual( $5, $1 );
                         forall = false;
+                        forall = false;
                         $$ = $5;
+                }
         | declaration_qualifier_list type_qualifier_list
+                {
                         if ( ($1->type && $1->type->qualifiers.val) || ($2->type && $2->type->qualifiers.val) ) { SemanticError( yylloc, "CV qualifiers cannot be distributed; only storage-class and forall qualifiers." ); }
+                        if ( ($1->type && $1->type->qualifiers.any()) || ($2->type && $2->type->qualifiers.any()) ) { SemanticError( yylloc, "CV qualifiers cannot be distributed; only storage-class and forall qualifiers." ); }
                         if ( ($1->type && $1->type->forall) || ($2->type && $2->type->forall) ) forall = true; // remember generic type
+                }
 …
+                {
                         distQual( $6, $1->addQualifiers( $2 ) );
                         forall = false;
+                        forall = false;
                         $$ = $6;
+                }
 …
                         $$ = $2->addFunctionBody( $4, $3 )->addType( $1 );
+                }
         | declaration_specifier variable_type_redeclarator with_clause_opt compound_statement
+        | declaration_specifier function_type_redeclarator with_clause_opt compound_statement
+                {
                         rebindForall( $1, $2 );
 …
         | variable_type_redeclarator
         | function_declarator
+        | function_type_redeclarator
+        ;
 subrange:
         constant_expression '~' constant_expression                     // CFA, integer subrange
                 { $$ = new ExpressionNode( new RangeExpr( maybeMoveBuild<Expression>( $1 ), maybeMoveBuild<Expression>( $3 ) ) ); }
+                { $$ = new ExpressionNode( new ast::RangeExpr( yylloc, maybeMoveBuild( $1 ), maybeMoveBuild( $3 ) ) ); }
+        ;
 …
+                {
                         DeclarationNode * name = new DeclarationNode();
                         name->asmName = $3;
+                        name->asmName = maybeMoveBuild( $3 );
                         $$ = name->addQualifiers( $5 );
+                }
 …
 variable_ptr:
         ptrref_operator variable_declarator
                 { $$ = $2->addPointer( DeclarationNode::newPointer( 0, $1 ) ); }
+                { $$ = $2->addPointer( DeclarationNode::newPointer( nullptr, $1 ) ); }
         | ptrref_operator type_qualifier_list variable_declarator
                 { $$ = $3->addPointer( DeclarationNode::newPointer( $2, $1 ) ); }
 …
         | '(' attribute_list variable_ptr ')' array_dimension
                 { $$ = $3->addQualifiers( $2 )->addArray( $5 ); }
         | '(' variable_array ')' multi_array_dimension          // redundant parenthesis
+        | '(' variable_array ')' multi_array_dimension          // redundant parenthesis
                 { $$ = $2->addArray( $4 ); }
         | '(' attribute_list variable_array ')' multi_array_dimension // redundant parenthesis
 …
 function_ptr:
         ptrref_operator function_declarator
                 { $$ = $2->addPointer( DeclarationNode::newPointer( 0, $1 ) ); }
+                { $$ = $2->addPointer( DeclarationNode::newPointer( nullptr, $1 ) ); }
         | ptrref_operator type_qualifier_list function_declarator
                 { $$ = $3->addPointer( DeclarationNode::newPointer( $2, $1 ) ); }
 …
 KR_function_ptr:
         ptrref_operator KR_function_declarator
                 { $$ = $2->addPointer( DeclarationNode::newPointer( 0, $1 ) ); }
+                { $$ = $2->addPointer( DeclarationNode::newPointer( nullptr, $1 ) ); }
         | ptrref_operator type_qualifier_list KR_function_declarator
                 { $$ = $3->addPointer( DeclarationNode::newPointer( $2, $1 ) ); }
 …
+        ;
 // This pattern parses a declaration for a variable or function prototype that redefines a type name, e.g.:
+// This pattern parses a declaration for a variable that redefines a type name, e.g.:
 //
 //              typedef int foo;
 …
 //                 int foo; // redefine typedef name in new scope
 //              }
-//
-// The pattern precludes declaring an array of functions versus a pointer to an array of functions, and returning arrays
-// and functions versus pointers to arrays and functions.
 paren_type:
 …
         paren_type attribute_list_opt
                 { $$ = $1->addQualifiers( $2 ); }
         | type_ptr
         | type_array attribute_list_opt
+        | variable_type_ptr
+        | variable_type_array attribute_list_opt
                 { $$ = $1->addQualifiers( $2 ); }
         | type_function attribute_list_opt
+        | variable_type_function attribute_list_opt
                 { $$ = $1->addQualifiers( $2 ); }
+        ;
 type_ptr:
+variable_type_ptr:
         ptrref_operator variable_type_redeclarator
                 { $$ = $2->addPointer( DeclarationNode::newPointer( 0, $1 ) ); }
+                { $$ = $2->addPointer( DeclarationNode::newPointer( nullptr, $1 ) ); }
         | ptrref_operator type_qualifier_list variable_type_redeclarator
                 { $$ = $3->addPointer( DeclarationNode::newPointer( $2, $1 ) ); }
         | '(' type_ptr ')' attribute_list_opt                           // redundant parenthesis
+        | '(' variable_type_ptr ')' attribute_list_opt          // redundant parenthesis
                 { $$ = $2->addQualifiers( $4 ); }
         | '(' attribute_list type_ptr ')' attribute_list_opt // redundant parenthesis
+        | '(' attribute_list variable_type_ptr ')' attribute_list_opt // redundant parenthesis
                 { $$ = $3->addQualifiers( $2 )->addQualifiers( $5 ); }
+        ;
 type_array:
+variable_type_array:
         paren_type array_dimension
                 { $$ = $1->addArray( $2 ); }
         | '(' type_ptr ')' array_dimension
+        | '(' variable_type_ptr ')' array_dimension
                 { $$ = $2->addArray( $4 ); }
         | '(' attribute_list type_ptr ')' array_dimension
+        | '(' attribute_list variable_type_ptr ')' array_dimension
                 { $$ = $3->addQualifiers( $2 )->addArray( $5 ); }
         | '(' type_array ')' multi_array_dimension                      // redundant parenthesis
+        | '(' variable_type_array ')' multi_array_dimension     // redundant parenthesis
                 { $$ = $2->addArray( $4 ); }
         | '(' attribute_list type_array ')' multi_array_dimension // redundant parenthesis
+        | '(' attribute_list variable_type_array ')' multi_array_dimension // redundant parenthesis
                 { $$ = $3->addQualifiers( $2 )->addArray( $5 ); }
         | '(' type_array ')'                                                            // redundant parenthesis
+        | '(' variable_type_array ')'                                           // redundant parenthesis
                 { $$ = $2; }
         | '(' attribute_list type_array ')'                                     // redundant parenthesis
+        | '(' attribute_list variable_type_array ')'            // redundant parenthesis
                 { $$ = $3->addQualifiers( $2 ); }
+        ;
+type_function:
+variable_type_function:
+        '(' variable_type_ptr ')' '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3)
+                { $$ = $2->addParamList( $6 ); }
+        | '(' attribute_list variable_type_ptr ')' '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3)
+                { $$ = $3->addQualifiers( $2 )->addParamList( $7 ); }
+        | '(' variable_type_function ')'                                        // redundant parenthesis
+                { $$ = $2; }
+        | '(' attribute_list variable_type_function ')'         // redundant parenthesis
+                { $$ = $3->addQualifiers( $2 ); }
+        ;
+// This pattern parses a declaration for a function prototype that redefines a type name.  It precludes declaring an
+// array of functions versus a pointer to an array of functions, and returning arrays and functions versus pointers to
+// arrays and functions.
+function_type_redeclarator:
+        function_type_no_ptr attribute_list_opt
+                { $$ = $1->addQualifiers( $2 ); }
+        | function_type_ptr
+        | function_type_array attribute_list_opt
+                { $$ = $1->addQualifiers( $2 ); }
+        ;
+function_type_no_ptr:
         paren_type '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3)
                 { $$ = $1->addParamList( $4 ); }
         | '(' type_ptr ')' '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3)
+        | '(' function_type_ptr ')' '(' push parameter_type_list_opt pop ')'
                 { $$ = $2->addParamList( $6 ); }
         | '(' attribute_list type_ptr ')' '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3)
+        | '(' attribute_list function_type_ptr ')' '(' push parameter_type_list_opt pop ')'
                 { $$ = $3->addQualifiers( $2 )->addParamList( $7 ); }
         | '(' type_function ')'                                                         // redundant parenthesis
+        | '(' function_type_no_ptr ')'                                          // redundant parenthesis
                 { $$ = $2; }
+        | '(' attribute_list type_function ')'                          // redundant parenthesis
+        | '(' attribute_list function_type_no_ptr ')'           // redundant parenthesis
+                { $$ = $3->addQualifiers( $2 ); }
+        ;
+function_type_ptr:
+        ptrref_operator function_type_redeclarator
+                { $$ = $2->addPointer( DeclarationNode::newPointer( nullptr, $1 ) ); }
+        | ptrref_operator type_qualifier_list function_type_redeclarator
+                { $$ = $3->addPointer( DeclarationNode::newPointer( $2, $1 ) ); }
+        | '(' function_type_ptr ')' attribute_list_opt
+                { $$ = $2->addQualifiers( $4 ); }
+        | '(' attribute_list function_type_ptr ')' attribute_list_opt
+                { $$ = $3->addQualifiers( $2 )->addQualifiers( $5 ); }
+        ;
+function_type_array:
+        '(' function_type_ptr ')' array_dimension
+                { $$ = $2->addArray( $4 ); }
+        | '(' attribute_list function_type_ptr ')' array_dimension
+                { $$ = $3->addQualifiers( $2 )->addArray( $5 ); }
+        | '(' function_type_array ')' multi_array_dimension     // redundant parenthesis
+                { $$ = $2->addArray( $4 ); }
+        | '(' attribute_list function_type_array ')' multi_array_dimension // redundant parenthesis
+                { $$ = $3->addQualifiers( $2 )->addArray( $5 ); }
+        | '(' function_type_array ')'                                           // redundant parenthesis
+                { $$ = $2; }
+        | '(' attribute_list function_type_array ')'            // redundant parenthesis
                 { $$ = $3->addQualifiers( $2 ); }
+        ;
 …
 identifier_parameter_ptr:
         ptrref_operator identifier_parameter_declarator
                 { $$ = $2->addPointer( DeclarationNode::newPointer( 0, $1 ) ); }
+                { $$ = $2->addPointer( DeclarationNode::newPointer( nullptr, $1 ) ); }
         | ptrref_operator type_qualifier_list identifier_parameter_declarator
                 { $$ = $3->addPointer( DeclarationNode::newPointer( $2, $1 ) ); }
 …
 type_parameter_ptr:
         ptrref_operator type_parameter_redeclarator
                 { $$ = $2->addPointer( DeclarationNode::newPointer( 0, $1 ) ); }
+                { $$ = $2->addPointer( DeclarationNode::newPointer( nullptr, $1 ) ); }
         | ptrref_operator type_qualifier_list type_parameter_redeclarator
                 { $$ = $3->addPointer( DeclarationNode::newPointer( $2, $1 ) ); }
 …
 abstract_ptr:
         ptrref_operator
                 { $$ = DeclarationNode::newPointer( 0, $1 ); }
+                { $$ = DeclarationNode::newPointer( nullptr, $1 ); }
         | ptrref_operator type_qualifier_list
                 { $$ = DeclarationNode::newPointer( $2, $1 ); }
         | ptrref_operator abstract_declarator
                 { $$ = $2->addPointer( DeclarationNode::newPointer( 0, $1 ) ); }
+                { $$ = $2->addPointer( DeclarationNode::newPointer( nullptr, $1 ) ); }
         | ptrref_operator type_qualifier_list abstract_declarator
                 { $$ = $3->addPointer( DeclarationNode::newPointer( $2, $1 ) ); }
 …
                 // Only the first dimension can be empty.
         '[' ']'
                 { $$ = DeclarationNode::newArray( 0, 0, false ); }
+                { $$ = DeclarationNode::newArray( nullptr, nullptr, false ); }
         | '[' ']' multi_array_dimension
                 { $$ = DeclarationNode::newArray( 0, 0, false )->addArray( $3 ); }
+                { $$ = DeclarationNode::newArray( nullptr, nullptr, false )->addArray( $3 ); }
                 // Cannot use constant_expression because of tuples => semantic check
         | '[' push assignment_expression pop ',' comma_expression ']' // CFA
                 { $$ = DeclarationNode::newArray( $3, 0, false )->addArray( DeclarationNode::newArray( $6, 0, false ) ); }
+                { $$ = DeclarationNode::newArray( $3, nullptr, false )->addArray( DeclarationNode::newArray( $6, nullptr, false ) ); }
                 // { SemanticError( yylloc, "New array dimension is currently unimplemented." ); $$ = nullptr; }
         | '[' push array_type_list pop ']'                                      // CFA
 …
 array_type_list:
         basic_type_name
                 { $$ = new ExpressionNode( new TypeExpr( maybeMoveBuildType( $1 ) ) ); }
+                { $$ = new ExpressionNode( new ast::TypeExpr( yylloc, maybeMoveBuildType( $1 ) ) ); }
         | type_name
                 { $$ = new ExpressionNode( new TypeExpr( maybeMoveBuildType( $1 ) ) ); }
+                { $$ = new ExpressionNode( new ast::TypeExpr( yylloc, maybeMoveBuildType( $1 ) ) ); }
         | assignment_expression upupeq assignment_expression
         | array_type_list ',' basic_type_name
                 { $$ = (ExpressionNode *)($1->set_last( new ExpressionNode( new TypeExpr( maybeMoveBuildType( $3 ) ) ) )); }
         | array_type_list ',' type_name
                 { $$ = (ExpressionNode *)($1->set_last( new ExpressionNode( new TypeExpr( maybeMoveBuildType( $3 ) ) ) )); }
+                { $$ = (ExpressionNode *)($1->set_last( new ExpressionNode( new ast::TypeExpr( yylloc, maybeMoveBuildType( $3 ) ) ) )); }
+        | array_type_list ',' type_name
+                { $$ = (ExpressionNode *)($1->set_last( new ExpressionNode( new ast::TypeExpr( yylloc, maybeMoveBuildType( $3 ) ) ) )); }
         | array_type_list ',' assignment_expression upupeq assignment_expression
+        ;
 …
         | ErangeUpEq
                 { $$ = OperKinds::LEThan; }
+        ;
+        ;
 multi_array_dimension:
         '[' push assignment_expression pop ']'
                 { $$ = DeclarationNode::newArray( $3, 0, false ); }
+                { $$ = DeclarationNode::newArray( $3, nullptr, false ); }
         | '[' push '*' pop ']'                                                          // C99
                 { $$ = DeclarationNode::newVarArray( 0 ); }
         | multi_array_dimension '[' push assignment_expression pop ']'
                 { $$ = $1->addArray( DeclarationNode::newArray( $4, 0, false ) ); }
+                { $$ = $1->addArray( DeclarationNode::newArray( $4, nullptr, false ) ); }
         | multi_array_dimension '[' push '*' pop ']'            // C99
                 { $$ = $1->addArray( DeclarationNode::newVarArray( 0 ) ); }
 …
 array_parameter_1st_dimension:
         '[' ']'
                 { $$ = DeclarationNode::newArray( 0, 0, false ); }
+                { $$ = DeclarationNode::newArray( nullptr, nullptr, false ); }
                 // multi_array_dimension handles the '[' '*' ']' case
         | '[' push type_qualifier_list '*' pop ']'                      // remaining C99
                 { $$ = DeclarationNode::newVarArray( $3 ); }
         | '[' push type_qualifier_list pop ']'
                 { $$ = DeclarationNode::newArray( 0, $3, false ); }
+                { $$ = DeclarationNode::newArray( nullptr, $3, false ); }
                 // multi_array_dimension handles the '[' assignment_expression ']' case
         | '[' push type_qualifier_list assignment_expression pop ']'
 …
 variable_abstract_ptr:
         ptrref_operator
                 { $$ = DeclarationNode::newPointer( 0, $1 ); }
+                { $$ = DeclarationNode::newPointer( nullptr, $1 ); }
         | ptrref_operator type_qualifier_list
                 { $$ = DeclarationNode::newPointer( $2, $1 ); }
         | ptrref_operator variable_abstract_declarator
                 { $$ = $2->addPointer( DeclarationNode::newPointer( 0, $1 ) ); }
+                { $$ = $2->addPointer( DeclarationNode::newPointer( nullptr, $1 ) ); }
         | ptrref_operator type_qualifier_list variable_abstract_declarator
                 { $$ = $3->addPointer( DeclarationNode::newPointer( $2, $1 ) ); }
 …
                 // No SUE declaration in parameter list.
         ptrref_operator type_specifier_nobody
                 { $$ = $2->addNewPointer( DeclarationNode::newPointer( 0, $1 ) ); }
+                { $$ = $2->addNewPointer( DeclarationNode::newPointer( nullptr, $1 ) ); }
         | type_qualifier_list ptrref_operator type_specifier_nobody
                 { $$ = $3->addNewPointer( DeclarationNode::newPointer( $1, $2 ) ); }
         | ptrref_operator cfa_abstract_function
                 { $$ = $2->addNewPointer( DeclarationNode::newPointer( 0, $1 ) ); }
+                { $$ = $2->addNewPointer( DeclarationNode::newPointer( nullptr, $1 ) ); }
         | type_qualifier_list ptrref_operator cfa_abstract_function
                 { $$ = $3->addNewPointer( DeclarationNode::newPointer( $1, $2 ) ); }
         | ptrref_operator cfa_identifier_parameter_declarator_tuple
                 { $$ = $2->addNewPointer( DeclarationNode::newPointer( 0, $1 ) ); }
+                { $$ = $2->addNewPointer( DeclarationNode::newPointer( nullptr, $1 ) ); }
         | type_qualifier_list ptrref_operator cfa_identifier_parameter_declarator_tuple
                 { $$ = $3->addNewPointer( DeclarationNode::newPointer( $1, $2 ) ); }
 …
                 // shift/reduce conflict with new-style empty (void) function return type.
         '[' ']' type_specifier_nobody
                 { $$ = $3->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
+                { $$ = $3->addNewArray( DeclarationNode::newArray( nullptr, nullptr, false ) ); }
         | cfa_array_parameter_1st_dimension type_specifier_nobody
                 { $$ = $2->addNewArray( $1 ); }
         | '[' ']' multi_array_dimension type_specifier_nobody
                 { $$ = $4->addNewArray( $3 )->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
+                { $$ = $4->addNewArray( $3 )->addNewArray( DeclarationNode::newArray( nullptr, nullptr, false ) ); }
         | cfa_array_parameter_1st_dimension multi_array_dimension type_specifier_nobody
                 { $$ = $3->addNewArray( $2 )->addNewArray( $1 ); }
 …
         | '[' ']' cfa_identifier_parameter_ptr
                 { $$ = $3->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
+                { $$ = $3->addNewArray( DeclarationNode::newArray( nullptr, nullptr, false ) ); }
         | cfa_array_parameter_1st_dimension cfa_identifier_parameter_ptr
                 { $$ = $2->addNewArray( $1 ); }
         | '[' ']' multi_array_dimension cfa_identifier_parameter_ptr
                 { $$ = $4->addNewArray( $3 )->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
+                { $$ = $4->addNewArray( $3 )->addNewArray( DeclarationNode::newArray( nullptr, nullptr, false ) ); }
         | cfa_array_parameter_1st_dimension multi_array_dimension cfa_identifier_parameter_ptr
                 { $$ = $3->addNewArray( $2 )->addNewArray( $1 ); }
 …
 cfa_abstract_ptr:                                                                               // CFA
         ptrref_operator type_specifier
                 { $$ = $2->addNewPointer( DeclarationNode::newPointer( 0, $1 ) ); }
+                { $$ = $2->addNewPointer( DeclarationNode::newPointer( nullptr, $1 ) ); }
         | type_qualifier_list ptrref_operator type_specifier
                 { $$ = $3->addNewPointer( DeclarationNode::newPointer( $1, $2 ) ); }
         | ptrref_operator cfa_abstract_function
                 { $$ = $2->addNewPointer( DeclarationNode::newPointer( 0, $1 ) ); }
+                { $$ = $2->addNewPointer( DeclarationNode::newPointer( nullptr, $1 ) ); }
         | type_qualifier_list ptrref_operator cfa_abstract_function
                 { $$ = $3->addNewPointer( DeclarationNode::newPointer( $1, $2 ) ); }
         | ptrref_operator cfa_abstract_declarator_tuple
                 { $$ = $2->addNewPointer( DeclarationNode::newPointer( 0, $1 ) ); }
+                { $$ = $2->addNewPointer( DeclarationNode::newPointer( nullptr, $1 ) ); }
         | type_qualifier_list ptrref_operator cfa_abstract_declarator_tuple
                 { $$ = $3->addNewPointer( DeclarationNode::newPointer( $1, $2 ) ); }

src/Parser/parserutility.cc

-              r34b4268
+              r24d6572
 // Created On       : Sat May 16 15:30:39 2015
 // Last Modified By : Andrew Beach
 // Last Modified On : Tus Jul 18 10:12:00 2017
 // Update Count     : 8
+// Last Modified On : Wed Mar  1 10:42:00 2023
+// Update Count     : 9
 //
 …
 #include <string>                // for string
+#include "SynTree/Constant.h"    // for Constant
+#include "SynTree/Expression.h"  // for UntypedExpr, CastExpr, ConstantExpr
+#include "SynTree/Type.h"        // for BasicType, ZeroType, BasicType::Kind...
+#include "AST/Expr.hpp"          // for UntypedExpr, CastExpr, ConstantExpr
+#include "AST/Type.hpp"          // for BasicType, ZeroType, BasicType::Kind...
 // rewrite
 …
 //    if ( (int)(x != 0) ) ...
+Expression *notZeroExpr( Expression *orig ) {
+        if( !orig ) return nullptr;
+        UntypedExpr *comparison = new UntypedExpr( new NameExpr( "?!=?" ) );
+        comparison->get_args().push_back( orig );
+        comparison->get_args().push_back( new ConstantExpr( Constant( new ZeroType( noQualifiers ), "0", (unsigned long long int)0 ) ) );
+        return new CastExpr( comparison, new BasicType( Type::Qualifiers(), BasicType::SignedInt ) );
+ast::Expr * notZeroExpr( ast::Expr * orig ) {
+        return ( !orig ) ? nullptr : new ast::CastExpr( orig->location,
+                ast::UntypedExpr::createCall( orig->location,
+                        "?!=?",
+                        {
+                                orig,
+                                new ast::ConstantExpr( orig->location,
+                                        new ast::ZeroType(),
+                                        "0",
+                                        std::optional<unsigned long long>( 0 )
+                                ),
+                        }
+                ),
+                new ast::BasicType( ast::BasicType::SignedInt )
+        );
+}

src/Parser/parserutility.h

-              r34b4268
+              r24d6572
 // file "LICENCE" distributed with Cforall.
 //
 // parserutility.h --
+// parserutility.h -- Collected utilities for the parser.
 //
 // Author           : Rodolfo G. Esteves
 // Created On       : Sat May 16 15:31:46 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 09:32:58 2017
 // Update Count     : 4
+// Last Modified By : Andrew Beach
+// Last Modified On : Tue Apr  4 14:03:00 2023
+// Update Count     : 7
 //
 #pragma once
+class Expression;
+#include "AST/Copy.hpp"            // for shallowCopy
+namespace ast {
+        class Expr;
+}
+Expression *notZeroExpr( Expression *orig );
+ast::Expr * notZeroExpr( ast::Expr *orig );
+template< typename T >
+static inline auto maybeBuild( T * orig ) -> decltype(orig->build()) {
+        return (orig) ? orig->build() : nullptr;
+}
+template< typename T >
+static inline auto maybeMoveBuild( T * orig ) -> decltype(orig->build()) {
+        auto ret = maybeBuild<T>(orig);
+        delete orig;
+        return ret;
+}
+template<typename node_t>
+node_t * maybeCopy( node_t const * node ) {
+        return node ? ast::shallowCopy( node ) : nullptr;
+}
 // Local Variables: //

src/ResolvExpr/AlternativeFinder.cc

-              r34b4268
+              r24d6572
 //
+#include "AlternativeFinder.h"
 #include <algorithm>               // for copy
 #include <cassert>                 // for strict_dynamic_cast, assert, assertf
 …
 #include "CompilationState.h"      // for resolvep
+#include "AdjustExprType.hpp"      // for adjustExprType
 #include "Alternative.h"           // for AltList, Alternative
-#include "AlternativeFinder.h"
 #include "AST/Expr.hpp"
 #include "AST/SymbolTable.hpp"
 #include "AST/Type.hpp"
+#include "CastCost.hpp"            // for castCost
 #include "Common/SemanticError.h"  // for SemanticError
 #include "Common/utility.h"        // for deleteAll, printAll, CodeLocation
+#include "ConversionCost.h"        // for conversionCost
 #include "Cost.h"                  // for Cost, Cost::zero, operator<<, Cost...
 #include "ExplodedActual.h"        // for ExplodedActual
 #include "InitTweak/InitTweak.h"   // for getFunctionName
+#include "PolyCost.hpp"            // for polyCost
 #include "RenameVars.h"            // for RenameVars, global_renamer
 #include "ResolveAssertions.h"     // for resolveAssertions
 #include "ResolveTypeof.h"         // for resolveTypeof
 #include "Resolver.h"              // for resolveStmtExpr
+#include "SpecCost.hpp"            // for specCost
 #include "SymTab/Indexer.h"        // for Indexer
 #include "SymTab/Mangler.h"        // for Mangler
 …
 #include "Tuples/Explode.h"        // for explode
 #include "Tuples/Tuples.h"         // for isTtype, handleTupleAssignment
+#include "typeops.h"               // for combos
 #include "Unify.h"                 // for unify
-#include "typeops.h"               // for adjustExprType, polyCost, castCost
 #define PRINT( text ) if ( resolvep ) { text }

src/ResolvExpr/AlternativeFinder.h

-              r34b4268
+              r24d6572
 namespace ResolvExpr {
         struct ArgPack;
+        Cost computeConversionCost( Type * actualType, Type * formalType, bool actualIsLvalue,
+                const SymTab::Indexer & indexer, const TypeEnvironment & env );
+        void referenceToRvalueConversion( Expression *& expr, Cost & cost );
         /// First index is which argument, second index is which alternative for that argument,

src/ResolvExpr/Candidate.cpp

-              r34b4268
+              r24d6572
 #include <iostream>
+#include <sstream>
 #include "AST/Print.hpp"
 …
         sorted.reserve(cands.size());
         for(const auto & c : cands) {
                 std::stringstream ss;
+                std::ostringstream ss;
                 print( ss, *c, indent );
                 sorted.push_back(ss.str());

src/ResolvExpr/CandidateFinder.cpp

-              r34b4268
+              r24d6572
 #include <vector>
+#include "AdjustExprType.hpp"
 #include "Candidate.hpp"
 #include "CompilationState.h"
 #include "Cost.h"
+#include "CastCost.hpp"
+#include "PolyCost.hpp"
+#include "SpecCost.hpp"
+#include "ConversionCost.h"
 #include "ExplodedArg.hpp"
 #include "RenameVars.h"           // for renameTyVars
 …
                                                         unify(
                                                                 ttype, argType, newResult.env, newResult.need, newResult.have,
                                                                 newResult.open, symtab )
+                                                                newResult.open )
                                                 ) {
                                                         finalResults.emplace_back( std::move( newResult ) );
 …
+                                )
                                 if ( unify( paramType, argType, env, need, have, open, symtab ) ) {
+                                if ( unify( paramType, argType, env, need, have, open ) ) {
                                         unsigned nextExpl = results[i].nextExpl + 1;
                                         if ( nextExpl == expl.exprs.size() ) { nextExpl = 0; }
 …
                                         ast::OpenVarSet open = results[i].open;
                                         if ( unify( paramType, cnst->result, env, need, have, open, symtab ) ) {
+                                        if ( unify( paramType, cnst->result, env, need, have, open ) ) {
                                                 results.emplace_back(
                                                         i, new ast::DefaultArgExpr{ cnst->location, cnst }, std::move( env ),
 …
                                 // attempt to unify types
                                 if ( unify( paramType, argType, env, need, have, open, symtab ) ) {
+                                if ( unify( paramType, argType, env, need, have, open ) ) {
                                         // add new result
                                         results.emplace_back(
 …
                                 if ( selfFinder.strictMode ) {
                                         if ( ! unifyExact(
                                                 returnType, targetType, funcEnv, funcNeed, funcHave, funcOpen, noWiden(), symtab ) // xxx - is no widening correct?
+                                                returnType, targetType, funcEnv, funcNeed, funcHave, funcOpen, noWiden() ) // xxx - is no widening correct?
                                         ) {
                                                 // unification failed, do not pursue this candidate
 …
                                 else {
                                         if ( ! unify(
                                                 returnType, targetType, funcEnv, funcNeed, funcHave, funcOpen, symtab )
+                                                returnType, targetType, funcEnv, funcNeed, funcHave, funcOpen )
                                         ) {
                                                 // unification failed, do not pursue this candidate
 …
                                 // unification run for side-effects
                                 unify( toType, cand->expr->result, cand->env, need, have, open, symtab );
+                                unify( toType, cand->expr->result, cand->env, need, have, open );
                                 Cost thisCost =
                                         (castExpr->isGenerated == ast::GeneratedFlag::GeneratedCast)
 …
                                                 if (
                                                         unify(
                                                                 r2->expr->result, r3->expr->result, env, need, have, open, symtab,
+                                                                r2->expr->result, r3->expr->result, env, need, have, open,
                                                                 common )
                                                 ) {
 …
                                         if (
                                                 unify(
                                                         r1->expr->result, r2->expr->result, env, need, have, open, symtab,
+                                                        r1->expr->result, r2->expr->result, env, need, have, open,
                                                         common )
                                         ) {
 …
                                         // unification run for side-effects
                                         bool canUnify = unify( toType, cand->expr->result, env, need, have, open, symtab );
+                                        bool canUnify = unify( toType, cand->expr->result, env, need, have, open );
                                         (void) canUnify;
                                         Cost thisCost = computeConversionCost( cand->expr->result, toType, cand->expr->get_lvalue(),

src/ResolvExpr/CandidateFinder.hpp

-              r34b4268
+              r24d6572
         const ast::SymbolTable & symtab, const ast::TypeEnvironment & env );
+/// Create an expression that preforms reference to rvalue conversion on
+/// the given expression and update the cost of the expression.
+const ast::Expr * referenceToRvalueConversion(
+        const ast::Expr * expr, Cost & cost );
 } // namespace ResolvExpr

src/ResolvExpr/CastCost.cc

-              r34b4268
+              r24d6572
 // Update Count     : 9
 //
+#include "CastCost.hpp"
 #include <cassert>                       // for assert
 …
 #include "ConversionCost.h"              // for ConversionCost
 #include "Cost.h"                        // for Cost, Cost::infinity
+#include "ResolvExpr/ConversionCost.h"   // for conversionCost
+#include "ResolvExpr/PtrsCastable.hpp"   // for ptrsCastable
 #include "ResolvExpr/TypeEnvironment.h"  // for TypeEnvironment, EqvClass
+#include "ResolvExpr/typeops.h"          // for ptrsCastable
+#include "ResolvExpr/Unify.h"            // for typesCompatibleIgnoreQualifiers
 #include "SymTab/Indexer.h"              // for Indexer
 #include "SynTree/Declaration.h"         // for TypeDecl, NamedTypeDecl
 #include "SynTree/Type.h"                // for PointerType, Type, TypeInstType
-#include "typeops.h"                     // for typesCompatibleIgnoreQualifiers
 #if 0
 …
                                 if (
                                         pointerType->qualifiers <= ptr->qualifiers
                                         && typesCompatibleIgnoreQualifiers( pointerType->base, ptr->base, symtab, env )
+                                        && typesCompatibleIgnoreQualifiers( pointerType->base, ptr->base, env )
                                 ) {
                                         cost = Cost::safe;
 …
+        )
         if ( typesCompatibleIgnoreQualifiers( src, dst, symtab, env ) ) {
+        if ( typesCompatibleIgnoreQualifiers( src, dst, env ) ) {
                 PRINT( std::cerr << "compatible!" << std::endl; )
                 if (dynamic_cast<const ast::ZeroType *>(dst) || dynamic_cast<const ast::OneType *>(dst)) {

src/ResolvExpr/CommonType.cc

-              r34b4268
+              r24d6572
 //
+#include "CommonType.hpp"
 #include <cassert>                       // for strict_dynamic_cast
 #include <map>                           // for _Rb_tree_const_iterator
 …
 #include "AST/Decl.hpp"
+#include "AST/Pass.hpp"
 #include "AST/Type.hpp"
 #include "Common/PassVisitor.h"
 …
                 const ast::Type * type2;
                 WidenMode widen;
-                const ast::SymbolTable & symtab;
                 ast::TypeEnvironment & tenv;
                 const ast::OpenVarSet & open;
 …
                 CommonType_new(
                         const ast::Type * t2, WidenMode w, const ast::SymbolTable & st,
+                        const ast::Type * t2, WidenMode w,
                         ast::TypeEnvironment & env, const ast::OpenVarSet & o,
                         ast::AssertionSet & need, ast::AssertionSet & have )
                 : type2( t2 ), widen( w ), symtab( st ), tenv( env ), open( o ), need (need), have (have) ,result() {}
+                : type2( t2 ), widen( w ), tenv( env ), open( o ), need (need), have (have) ,result() {}
                 void previsit( const ast::Node * ) { visit_children = false; }
 …
                                         ast::AssertionSet need, have;
                                         if ( ! tenv.bindVar(
                                                 var, voidPtr->base, entry->second, need, have, open, widen, symtab )
+                                                var, voidPtr->base, entry->second, need, have, open, widen )
                                         ) return;
+                                }
 …
                                 ast::OpenVarSet newOpen{ open };
                                 if (enumInst->base->base
                                 && unifyExact(type1, enumInst->base->base, tenv, need, have, newOpen, widen, symtab)) {
+                                && unifyExact(type1, enumInst->base->base, tenv, need, have, newOpen, widen)) {
                                         result = type1;
                                         return true;
 …
                                         ast::OpenVarSet newOpen{ open };
                                         if ( unifyExact( t1, t2, tenv, have, need, newOpen, noWiden(), symtab ) ) {
+                                        if ( unifyExact( t1, t2, tenv, have, need, newOpen, noWiden() ) ) {
                                                 result = pointer;
                                                 if ( q1.val != q2.val ) {
 …
                                                                 if (unifyExact(
                                                                         arg1, tupleFromTypes( crnt2, end2 ), tenv, need, have, open,
                                                                         noWiden(), symtab )) {
+                                                                        noWiden() )) {
                                                                                 break;
 …
                                                                 if (unifyExact(
                                                                         tupleFromTypes( crnt1, end1 ), arg2, tenv, need, have, open,
                                                                         noWiden(), symtab )) {
+                                                                        noWiden() )) {
                                                                                 break;
 …
                                                                                 if ( ! unifyExact(
                                                                                         base1, base2, tenv, need, have, open, noWiden(), symtab )
+                                                                                        base1, base2, tenv, need, have, open, noWiden() )
                                                                                 ) return;
+                                                                        }
 …
                                                                                 if ( ! unifyExact(
                                                                                         base1, base2, tenv, need, have, open, noWiden(), symtab )
+                                                                                        base1, base2, tenv, need, have, open, noWiden() )
                                                                                 ) return;
+                                                                        }
 …
+                                                        }
                                                         else if (! unifyExact(
                                                                 arg1, arg2, tenv, need, have, open, noWiden(), symtab )) return;
+                                                                arg1, arg2, tenv, need, have, open, noWiden() )) return;
                                                         ++crnt1; ++crnt2;
 …
                                                         if (! unifyExact(
                                                                 t1, tupleFromTypes( crnt2, end2 ), tenv, need, have, open,
                                                                 noWiden(), symtab )) return;
+                                                                noWiden() )) return;
                                                 } else if ( crnt2 != end2 ) {
                                                         // try unifying empty tuple with ttype
 …
                                                         if (! unifyExact(
                                                                 tupleFromTypes( crnt1, end1 ), t2, tenv, need, have, open,
                                                                 noWiden(), symtab )) return;
+                                                                noWiden() )) return;
+                                                }
                                                 if ((f1->returns.size() == 0 && f2->returns.size() == 0)
                                                   || (f1->returns.size() == 1 && f2->returns.size() == 1 && unifyExact(f1->returns[0], f2->returns[0], tenv, need, have, open, noWiden(), symtab))) {
+                                                  || (f1->returns.size() == 1 && f2->returns.size() == 1 && unifyExact(f1->returns[0], f2->returns[0], tenv, need, have, open, noWiden()))) {
                                                         result = pointer;
 …
                                         ast::OpenVarSet newOpen{ open };
                                         if ( unifyExact( t1, t2, tenv, have, need, newOpen, noWiden(), symtab ) ) {
+                                        if ( unifyExact( t1, t2, tenv, have, need, newOpen, noWiden() ) ) {
                                                 result = ref;
                                                 if ( q1.val != q2.val ) {
 …
                         } else {
                                 if (!dynamic_cast<const ast::EnumInstType *>(type2))
                                         result = commonType( type2, ref, tenv, need, have, open, widen, symtab );
+                                        result = commonType( type2, ref, tenv, need, have, open, widen );
+                        }
+                }
 …
                 void postvisit( const ast::EnumInstType * enumInst ) {
                         if (!dynamic_cast<const ast::EnumInstType *>(type2))
                                 result = commonType( type2, enumInst, tenv, need, have, open, widen, symtab);
+                                result = commonType( type2, enumInst, tenv, need, have, open, widen);
+                }
                 void postvisit( const ast::TraitInstType * ) {}
+                void postvisit( const ast::TypeInstType * inst ) {
+                        if ( ! widen.first ) return;
+                        if ( const ast::NamedTypeDecl * nt = symtab.lookupType( inst->name ) ) {
+                                if ( const ast::Type * base =
+                                                strict_dynamic_cast< const ast::TypeDecl * >( nt )->base
+                                ) {
+                                        ast::CV::Qualifiers q1 = inst->qualifiers, q2 = type2->qualifiers;
+                                        // force t{1,2} to be cloned if their qualifiers must be mutated
+                                        ast::ptr< ast::Type > t1{ base }, t2{ type2 };
+                                        reset_qualifiers( t1, q1 );
+                                        reset_qualifiers( t2 );
+                                        ast::OpenVarSet newOpen{ open };
+                                        if ( unifyExact( t1, t2, tenv, have, need, newOpen, noWiden(), symtab ) ) {
+                                                result = type2;
+                                                reset_qualifiers( result, q1 | q2 );
+                                        } else {
+                                                tryResolveWithTypedEnum( t1 );
+                                        }
+                                }
+                        }
+                }
+                void postvisit( const ast::TypeInstType * inst ) {}
                 void postvisit( const ast::TupleType * tuple) {
 …
                 ast::ptr< ast::Type > handleReference(
                         const ast::ptr< ast::Type > & t1, const ast::ptr< ast::Type > & t2, WidenMode widen,
                         const ast::SymbolTable & symtab, ast::TypeEnvironment & env,
+                        ast::TypeEnvironment & env,
                         const ast::OpenVarSet & open
                 ) {
 …
                         // need unify to bind type variables
                         if ( unify( t1, t2, env, have, need, newOpen, symtab, common ) ) {
+                        if ( unify( t1, t2, env, have, need, newOpen, common ) ) {
                                 ast::CV::Qualifiers q1 = t1->qualifiers, q2 = t2->qualifiers;
                                 PRINT(
 …
                         const ast::ptr< ast::Type > & type1, const ast::ptr< ast::Type > & type2,
                         ast::TypeEnvironment & env, ast::AssertionSet & need, ast::AssertionSet & have,
                         const ast::OpenVarSet & open, WidenMode widen, const ast::SymbolTable & symtab
+                        const ast::OpenVarSet & open, WidenMode widen
         ) {
                 unsigned depth1 = type1->referenceDepth();
 …
                         if ( depth1 > depth2 ) {
                                 assert( ref1 );
                                 result = handleReference( ref1->base, type2, widen, symtab, env, open );
+                                result = handleReference( ref1->base, type2, widen, env, open );
                         } else {  // implies depth1 < depth2
                                 assert( ref2 );
                                 result = handleReference( type1, ref2->base, widen, symtab, env, open );
+                                result = handleReference( type1, ref2->base, widen, env, open );
+                        }
 …
+                }
                 // otherwise both are reference types of the same depth and this is handled by the visitor
                 ast::Pass<CommonType_new> visitor{ type2, widen, symtab, env, open, need, have };
+                ast::Pass<CommonType_new> visitor{ type2, widen, env, open, need, have };
                 type1->accept( visitor );
+                ast::ptr< ast::Type > result = visitor.core.result;
+                // handling for opaque type declarations (?)
+                if ( ! result && widen.second ) {
+                        if ( const ast::TypeInstType * inst = type2.as< ast::TypeInstType >() ) {
+                                if ( const ast::NamedTypeDecl * nt = symtab.lookupType( inst->name ) ) {
+                                        auto type = strict_dynamic_cast< const ast::TypeDecl * >( nt );
+                                        if ( type->base ) {
+                                                ast::CV::Qualifiers q1 = type1->qualifiers, q2 = type2->qualifiers;
+                                                ast::OpenVarSet newOpen{ open };
+                                                // force t{1,2} to be cloned if its qualifiers must be stripped, so that
+                                                // type1 and type->base are left unchanged; calling convention forces
+                                                // {type1,type->base}->strong_ref >= 1
+                                                ast::ptr<ast::Type> t1{ type1 }, t2{ type->base };
+                                                reset_qualifiers( t1 );
+                                                reset_qualifiers( t2, q1 );
+                                                if ( unifyExact( t1, t2, env, have, need, newOpen, noWiden(), symtab ) ) {
+                                                        result = t1;
+                                                        reset_qualifiers( result, q1 | q2 );
+                                                }
+                                        }
+                                }
+                        }
+                }
+                return result;
+                // ast::ptr< ast::Type > result = visitor.core.result;
+                return visitor.core.result;
+        }

src/ResolvExpr/ConversionCost.cc

-              r34b4268
+              r24d6572
 #include "ResolvExpr/Cost.h"             // for Cost
 #include "ResolvExpr/TypeEnvironment.h"  // for EqvClass, TypeEnvironment
+#include "ResolvExpr/Unify.h"
+#include "ResolvExpr/Unify.h"            // for typesCompatibleIgnoreQualifiers
+#include "ResolvExpr/PtrsAssignable.hpp" // for ptrsAssignable
 #include "SymTab/Indexer.h"              // for Indexer
 #include "SynTree/Declaration.h"         // for TypeDecl, NamedTypeDecl
 #include "SynTree/Type.h"                // for Type, BasicType, TypeInstType
-#include "typeops.h"                     // for typesCompatibleIgnoreQualifiers
 …
+                }
+        }
         if ( typesCompatibleIgnoreQualifiers( src, dst, symtab, env ) ) {
+        if ( typesCompatibleIgnoreQualifiers( src, dst, env ) ) {
                 return Cost::zero;
         } else if ( dynamic_cast< const ast::VoidType * >( dst ) ) {
 …
                         ast::CV::Qualifiers tq2 = dstAsRef->base->qualifiers;
                         if ( tq1 <= tq2 && typesCompatibleIgnoreQualifiers(
                                         srcAsRef->base, dstAsRef->base, symtab, env ) ) {
+                                        srcAsRef->base, dstAsRef->base, env ) ) {
                                 if ( tq1 == tq2 ) {
                                         return Cost::zero;
 …
                 const ast::ReferenceType * dstAsRef = dynamic_cast< const ast::ReferenceType * >( dst );
                 assert( dstAsRef );
                 if ( typesCompatibleIgnoreQualifiers( src, dstAsRef->base, symtab, env ) ) {
+                if ( typesCompatibleIgnoreQualifiers( src, dstAsRef->base, env ) ) {
                         if ( srcIsLvalue ) {
                                 if ( src->qualifiers == dstAsRef->base->qualifiers ) {
 …
                 ast::CV::Qualifiers tq2 = dstAsPtr->base->qualifiers;
                 if ( tq1 <= tq2 && typesCompatibleIgnoreQualifiers(
                                 pointerType->base, dstAsPtr->base, symtab, env ) ) {
+                                pointerType->base, dstAsPtr->base, env ) ) {
                         if ( tq1 == tq2 ) {
                                 cost = Cost::zero;

src/ResolvExpr/ConversionCost.h

-              r34b4268
+              r24d6572
 namespace ResolvExpr {
         class TypeEnvironment;
+        Cost conversionCost(
+                const Type * src, const Type * dest, bool srcIsLvalue,
+                const SymTab::Indexer & indexer, const TypeEnvironment & env );
         typedef std::function<Cost(const Type *, const Type *, bool,
 …
         const ast::SymbolTable &, const ast::TypeEnvironment &)>;
+Cost conversionCost(
+        const ast::Type * src, const ast::Type * dst, bool srcIsLvalue,
+        const ast::SymbolTable & symtab, const ast::TypeEnvironment & env );
+Cost convertToReferenceCost( const ast::Type * src, const ast::ReferenceType * dest,
+        bool srcIsLvalue, const ast::SymbolTable & indexer, const ast::TypeEnvironment & env,
+        PtrsCalculation func );
 #warning when the old ConversionCost is removed, get ride of the _new suffix.
 class ConversionCost_new : public ast::WithShortCircuiting {
 …
 };
-Cost convertToReferenceCost( const ast::Type * src, const ast::ReferenceType * dest,
-        bool srcIsLvalue, const ast::SymbolTable & indexer, const ast::TypeEnvironment & env,
-        PtrsCalculation func );
 } // namespace ResolvExpr

src/ResolvExpr/CurrentObject.cc

-              r34b4268
+              r24d6572
 // Author           : Rob Schluntz
 // Created On       : Tue Jun 13 15:28:32 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Jul  1 09:16:01 2022
 // Update Count     : 15
+// Last Modified By : Andrew Beach
+// Last Modified On : Mon Apr 10  9:40:00 2023
+// Update Count     : 18
 //
 …
 #include "AST/Init.hpp"                // for Designation
 #include "AST/Node.hpp"                // for readonly
 #include "AST/Print.hpp"                // for readonly
+#include "AST/Print.hpp"               // for readonly
 #include "AST/Type.hpp"
+#include "Common/Eval.h"               // for eval
 #include "Common/Indenter.h"           // for Indenter, operator<<
 #include "Common/SemanticError.h"      // for SemanticError
 …
 namespace ast {
+        /// Iterates members of a type by initializer.
+        class MemberIterator {
+        public:
+                virtual ~MemberIterator() {}
+                /// Internal set position based on iterator ranges.
+                virtual void setPosition(
+                        std::deque< ptr< Expr > >::const_iterator it,
+                        std::deque< ptr< Expr > >::const_iterator end ) = 0;
+                /// Walks the current object using the given designators as a guide.
+                void setPosition( const std::deque< ptr< Expr > > & designators ) {
+                        setPosition( designators.begin(), designators.end() );
+                }
+                /// Retrieve the list of possible (Type,Designation) pairs for the
+                /// current position in the current object.
+                virtual std::deque< InitAlternative > operator* () const = 0;
+                /// True if the iterator is not currently at the end.
+                virtual operator bool() const = 0;
+                /// Moves the iterator by one member in the current object.
+                virtual MemberIterator & bigStep() = 0;
+                /// Moves the iterator by one member in the current subobject.
+                virtual MemberIterator & smallStep() = 0;
+                /// The type of the current object.
+                virtual const Type * getType() = 0;
+                /// The type of the current subobject.
+                virtual const Type * getNext() = 0;
+                /// Helper for operator*; aggregates must add designator to each init
+                /// alternative, but adding designators in operator* creates duplicates.
+                virtual std::deque< InitAlternative > first() const = 0;
+        };
         /// create a new MemberIterator that traverses a type correctly
         MemberIterator * createMemberIterator( const CodeLocation & loc, const Type * type );
 …
         };
+        /// Iterates array types
+        class ArrayIterator final : public MemberIterator {
+        /// Iterates over an indexed type:
+        class IndexIterator : public MemberIterator {
+        protected:
                 CodeLocation location;
-                const ArrayType * array = nullptr;
-                const Type * base = nullptr;
                 size_t index = 0;
                 size_t size = 0;
+                std::unique_ptr< MemberIterator > memberIter;
+                void setSize( const Expr * expr ) {
+                        auto res = eval( expr );
+                        if ( ! res.second ) {
+                                SemanticError( location, toString( "Array designator must be a constant expression: ", expr ) );
+                        }
+                        size = res.first;
+                }
+        public:
+                ArrayIterator( const CodeLocation & loc, const ArrayType * at ) : location( loc ), array( at ), base( at->base ) {
+                        PRINT( std::cerr << "Creating array iterator: " << at << std::endl; )
+                        memberIter.reset( createMemberIterator( loc, base ) );
+                        if ( at->isVarLen ) {
+                                SemanticError( location, at, "VLA initialization does not support @=: " );
+                        }
+                        setSize( at->dimension );
+                }
+                std::unique_ptr<MemberIterator> memberIter;
+        public:
+                IndexIterator( const CodeLocation & loc, size_t size ) :
+                        location( loc ), size( size )
+                {}
                 void setPosition( const Expr * expr ) {
 …
                         auto arg = eval( expr );
                         index = arg.first;
-                        return;
                         // if ( auto constExpr = dynamic_cast< const ConstantExpr * >( expr ) ) {
 …
                 void setPosition(
                         std::deque< ptr< Expr > >::const_iterator begin,
                         std::deque< ptr< Expr > >::const_iterator end
+                        std::deque<ast::ptr<ast::Expr>>::const_iterator begin,
+                        std::deque<ast::ptr<ast::Expr>>::const_iterator end
                 ) override {
                         if ( begin == end ) return;
 …
                 operator bool() const override { return index < size; }
+        };
+        /// Iterates over the members of array types:
+        class ArrayIterator final : public IndexIterator {
+                const ArrayType * array = nullptr;
+                const Type * base = nullptr;
+                size_t getSize( const Expr * expr ) {
+                        auto res = eval( expr );
+                        if ( !res.second ) {
+                                SemanticError( location, toString( "Array designator must be a constant expression: ", expr ) );
+                        }
+                        return res.first;
+                }
+        public:
+                ArrayIterator( const CodeLocation & loc, const ArrayType * at ) :
+                                IndexIterator( loc, getSize( at->dimension) ),
+                                array( at ), base( at->base ) {
+                        PRINT( std::cerr << "Creating array iterator: " << at << std::endl; )
+                        memberIter.reset( createMemberIterator( loc, base ) );
+                        if ( at->isVarLen ) {
+                                SemanticError( location, at, "VLA initialization does not support @=: " );
+                        }
+                }
                 ArrayIterator & bigStep() override {
 …
                 const Type * getNext() final {
+                        return ( memberIter && *memberIter ) ? memberIter->getType() : nullptr;
+                        bool hasMember = memberIter && *memberIter;
+                        return hasMember ? memberIter->getType() : nullptr;
+                }
 …
         };
+        class TupleIterator final : public AggregateIterator {
+        public:
+                TupleIterator( const CodeLocation & loc, const TupleType * inst )
+                : AggregateIterator(
+                        loc, "TupleIterator", toString("Tuple", inst->size()), inst, inst->members
+                ) {}
+                operator bool() const override {
+                        return curMember != members.end() || (memberIter && *memberIter);
+        /// Iterates across the positions in a tuple:
+        class TupleIterator final : public IndexIterator {
+                ast::TupleType const * const tuple;
+                const ast::Type * typeAtIndex() const {
+                        assert( index < size );
+                        return tuple->types[ index ].get();
+                }
+        public:
+                TupleIterator( const CodeLocation & loc, const TupleType * type )
+                : IndexIterator( loc, type->size() ), tuple( type ) {
+                        PRINT( std::cerr << "Creating tuple iterator: " << type << std::endl; )
+                        memberIter.reset( createMemberIterator( loc, typeAtIndex() ) );
+                }
                 TupleIterator & bigStep() override {
+                        PRINT( std::cerr << "bigStep in " << kind << std::endl; )
+                        atbegin = false;
+                        memberIter = nullptr;
+                        curType = nullptr;
+                        while ( curMember != members.end() ) {
+                                ++curMember;
+                                if ( init() ) return *this;
+                        }
+                        ++index;
+                        memberIter.reset( index < size ?
+                                createMemberIterator( location, typeAtIndex() ) : nullptr );
                         return *this;
+                }
+                TupleIterator & smallStep() override {
+                        if ( memberIter ) {
+                                PRINT( std::cerr << "has member iter: " << *memberIter << std::endl; )
+                                memberIter->smallStep();
+                                if ( !memberIter ) {
+                                        PRINT( std::cerr << "has valid member iter" << std::endl; )
+                                        return *this;
+                                }
+                        }
+                        return bigStep();
+                }
+                const ast::Type * getType() override {
+                        return tuple;
+                }
+                const ast::Type * getNext() override {
+                        bool hasMember = memberIter && *memberIter;
+                        return hasMember ? memberIter->getType() : nullptr;
+                }
+                std::deque< InitAlternative > first() const override {
+                        PRINT( std::cerr << "first in TupleIterator (" << index << "/" << size << ")" << std::endl; )
+                        if ( memberIter && *memberIter ) {
+                                std::deque< InitAlternative > ret = memberIter->first();
+                                for ( InitAlternative & alt : ret ) {
+                                        alt.designation.get_and_mutate()->designators.emplace_front(
+                                                ConstantExpr::from_ulong( location, index ) );
+                                }
+                                return ret;
+                        }
+                        return {};
+                }
         };

src/ResolvExpr/CurrentObject.h

-              r34b4268
+              r24d6572
 // Author           : Rob Schluntz
 // Created On       : Thu Jun  8 11:07:25 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 09:36:48 2017
 // Update Count     : 3
+// Last Modified By : Andrew Beach
+// Last Modified On : Thu Apr  6 16:14:00 2023
+// Update Count     : 4
 //
 …
         /// Iterates members of a type by initializer
+        class MemberIterator {
+        public:
+                virtual ~MemberIterator() {}
+                /// Internal set position based on iterator ranges
+                virtual void setPosition(
+                        std::deque< ptr< Expr > >::const_iterator it,
+                        std::deque< ptr< Expr > >::const_iterator end ) = 0;
+                /// walks the current object using the given designators as a guide
+                void setPosition( const std::deque< ptr< Expr > > & designators ) {
+                        setPosition( designators.begin(), designators.end() );
+                }
+                /// retrieve the list of possible (Type,Designation) pairs for the current position in the
+                /// current object
+                virtual std::deque< InitAlternative > operator* () const = 0;
+                /// true if the iterator is not currently at the end
+                virtual operator bool() const = 0;
+                /// moves the iterator by one member in the current object
+                virtual MemberIterator & bigStep() = 0;
+                /// moves the iterator by one member in the current subobject
+                virtual MemberIterator & smallStep() = 0;
+                /// the type of the current object
+                virtual const Type * getType() = 0;
+                /// the type of the current subobject
+                virtual const Type * getNext() = 0;
+                /// helper for operator*; aggregates must add designator to each init alternative, but
+                /// adding designators in operator* creates duplicates
+                virtual std::deque< InitAlternative > first() const = 0;
+        };
+        class MemberIterator;
         /// Builds initializer lists in resolution

src/ResolvExpr/ExplodedArg.hpp

r34b4268	r24d6572
35	35	ExplodedArg() : env(), cost( Cost::zero ), exprs() {}
36	36	ExplodedArg( const Candidate & arg, const ast::SymbolTable & symtab );
37
	37
38	38	ExplodedArg( ExplodedArg && ) = default;
39	39	ExplodedArg & operator= ( ExplodedArg && ) = default;

src/ResolvExpr/PolyCost.cc

r34b4268	r24d6572
15	15
16	16	#include "AST/SymbolTable.hpp"
	17	#include "AST/Pass.hpp"
17	18	#include "AST/Type.hpp"
18	19	#include "AST/TypeEnvironment.hpp"

src/ResolvExpr/PtrsAssignable.cc

r34b4268	r24d6572
14	14	//
15	15
16		#include "~~typeops.h~~"
	16	#include "PtrsAssignable.hpp"
17	17
18	18	#include "AST/Pass.hpp"

src/ResolvExpr/PtrsCastable.cc

-              r34b4268
+              r24d6572
 //
+#include "PtrsCastable.hpp"
 #include "AST/Decl.hpp"
 #include "AST/Pass.hpp"
 …
 #include "AST/TypeEnvironment.hpp"
 #include "Common/PassVisitor.h"
+#include "ResolvExpr/PtrsAssignable.hpp" // for ptrsAssignable
 #include "ResolvExpr/TypeEnvironment.h"  // for EqvClass, TypeEnvironment
 #include "SymTab/Indexer.h"              // for Indexer
 …
 #include "SynTree/Type.h"                // for TypeInstType, Type, BasicType
 #include "SynTree/Visitor.h"             // for Visitor
-#include "typeops.h"                     // for ptrsAssignable
 namespace ResolvExpr {
 …
                 return objectCast( src, env, symtab );
         } else {
+                ast::Pass< PtrsCastable_new > ptrs{ dst, env, symtab };
+                src->accept( ptrs );
+                return ptrs.core.result;
+                return ast::Pass<PtrsCastable_new>::read( src, dst, env, symtab );
+        }
+}

src/ResolvExpr/RenameVars.cc

-              r34b4268
+              r24d6572
                 const ast::TypeInstType * rename( const ast::TypeInstType * type ) {
-                        // rename
                         auto it = idMap.find( type->name );
+                        if ( it != idMap.end() ) {
+                                // unconditionally mutate because map will *always* have different name
+                                ast::TypeInstType * mut = ast::shallowCopy( type );
+                                // reconcile base node since some copies might have been made
+                                mut->base = it->second.base;
+                                mut->formal_usage = it->second.formal_usage;
+                                mut->expr_id = it->second.expr_id;
+                    type = mut;
+                        }
+                        return type;
+                        if ( it == idMap.end() ) return type;
+                        // Unconditionally mutate because map will *always* have different name.
+                        ast::TypeInstType * mut = ast::shallowCopy( type );
+                        // Reconcile base node since some copies might have been made.
+                        mut->base = it->second.base;
+                        mut->formal_usage = it->second.formal_usage;
+                        mut->expr_id = it->second.expr_id;
+                        return mut;
+                }
 …
 const ast::Type * renameTyVars( const ast::Type * t, RenameMode mode, bool reset ) {
-        // ast::Type *tc = ast::deepCopy(t);
         ast::Pass<RenameVars_new> renamer;
         renamer.core.mode = mode;

src/ResolvExpr/ResolveAssertions.cc

-              r34b4268
+              r24d6572
 #include <vector>                   // for vector
+#include "AdjustExprType.hpp"       // for adjustExprType
 #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 "GenPoly/GenPoly.h"        // for getFunctionType
+#include "ResolvExpr/AlternativeFinder.h"  // for computeConversionCost
 #include "ResolvExpr/RenameVars.h"  // for renameTyVars
+#include "SpecCost.hpp"             // for specCost
 #include "SymTab/Indexer.h"         // for Indexer
 #include "SymTab/Mangler.h"         // for Mangler
 #include "SynTree/Expression.h"     // for InferredParams
 #include "TypeEnvironment.h"        // for TypeEnvironment, etc.
-#include "typeops.h"                // for adjustExprType, specCost
 #include "Unify.h"                  // for unify

src/ResolvExpr/Resolver.cc

-              r34b4268
+              r24d6572
 #include "AST/SymbolTable.hpp"
 #include "AST/Type.hpp"
+#include "Common/Eval.h"                 // for eval
+#include "Common/Iterate.hpp"            // for group_iterate
 #include "Common/PassVisitor.h"          // for PassVisitor
 #include "Common/SemanticError.h"        // for SemanticError
 #include "Common/Stats/ResolveTime.h"    // for ResolveTime::start(), ResolveTime::stop()
 #include "Common/utility.h"              // for ValueGuard, group_iterate
+#include "Common/ToString.hpp"           // for toCString
 #include "InitTweak/GenInit.h"
 #include "InitTweak/InitTweak.h"         // for isIntrinsicSingleArgCallStmt
 …
                 void removeExtraneousCast( ast::ptr<ast::Expr> & expr, const ast::SymbolTable & symtab ) {
                         if ( const ast::CastExpr * castExpr = expr.as< ast::CastExpr >() ) {
                                 if ( typesCompatible( castExpr->arg->result, castExpr->result, symtab ) ) {
+                                if ( typesCompatible( castExpr->arg->result, castExpr->result ) ) {
                                         // cast is to the same type as its argument, remove it
                                         swap_and_save_env( expr, castExpr->arg );
 …
                         // Find all candidates for a function in canonical form
                         funcFinder.find( clause.target_func, ResolvMode::withAdjustment() );
+                        funcFinder.find( clause.target, ResolvMode::withAdjustment() );
                         if ( funcFinder.candidates.empty() ) {
                                 stringstream ss;
                                 ss << "Use of undeclared indentifier '";
                                 ss << clause.target_func.strict_as< ast::NameExpr >()->name;
+                                ss << clause.target.strict_as< ast::NameExpr >()->name;
                                 ss << "' in call to waitfor";
                                 SemanticError( stmt->location, ss.str() );
 …
                                                                 if (
                                                                         ! unify(
+                                                                                arg->expr->result, *param, resultEnv, need, have, open,
+                                                                                symtab )
+                                                                                arg->expr->result, *param, resultEnv, need, have, open )
                                                                 ) {
                                                                         // Type doesn't match
 …
                         auto clause2 = new ast::WaitForClause( clause.location );
                         clause2->target_func = funcCandidates.front()->expr;
+                        clause2->target = funcCandidates.front()->expr;
                         clause2->target_args.reserve( clause.target_args.size() );
 …
                         // Resolve the conditions as if it were an IfStmt, statements normally
                         clause2->cond = findSingleExpression( clause.cond, context );
+                        clause2->when_cond = findSingleExpression( clause.when_cond, context );
                         clause2->stmt = clause.stmt->accept( *visitor );

src/ResolvExpr/Resolver.h

r34b4268	r24d6572
34	34	class Decl;
35	35	class DeletedExpr;
	36	class Expr;
36	37	class Init;
37	38	class StmtExpr;

src/ResolvExpr/SatisfyAssertions.cpp

-              r34b4268
+              r24d6572
 #include <vector>
+#include "AdjustExprType.hpp"
 #include "Candidate.hpp"
 #include "CandidateFinder.hpp"
+#include "CommonType.hpp"
 #include "Cost.h"
 #include "RenameVars.h"
+#include "SpecCost.hpp"
 #include "typeops.h"
 #include "Unify.h"
 …
                                 .strict_as<ast::FunctionType>()->params[0]
                                 .strict_as<ast::ReferenceType>()->base;
+                        sat.cand->env.apply(thisArgType);
+                        // sat.cand->env.apply(thisArgType);
+                        if (auto inst = thisArgType.as<ast::TypeInstType>()) {
+                                auto cls = sat.cand->env.lookup(*inst);
+                                if (cls && cls->bound) thisArgType = cls->bound;
+                        }
                         std::string otypeKey = "";
 …
                         ast::TypeEnvironment tempNewEnv {newEnv};
                         if ( unifyExact( toType, adjType, tempNewEnv, newNeed, have, newOpen, WidenMode {true, true}, sat.symtab ) ) {
+                        if ( unifyExact( toType, adjType, tempNewEnv, newNeed, have, newOpen, WidenMode {true, true} ) ) {
                                 // set up binding slot for recursive assertions
                                 ast::UniqueId crntResnSlot = 0;
 …
                                 // newEnv = sat.cand->env;
                                 // newNeed.clear();
                                 if ( auto c = commonType( toType, adjType, newEnv, newNeed, have, newOpen, WidenMode {true, true}, sat.symtab ) ) {
+                                if ( auto c = commonType( toType, adjType, newEnv, newNeed, have, newOpen, WidenMode {true, true} ) ) {
                                         // set up binding slot for recursive assertions
                                         ast::UniqueId crntResnSlot = 0;
 …
                         mergeOpenVars( open, i.match.open );
                         if ( ! env.combine( i.match.env, open, symtab ) ) return false;
+                        if ( ! env.combine( i.match.env, open ) ) return false;
                         crnt.emplace_back( i );

src/ResolvExpr/Unify.cc

-              r34b4268
+              r24d6572
 #include "AST/TypeEnvironment.hpp"
 #include "Common/PassVisitor.h"     // for PassVisitor
+#include "CommonType.hpp"           // for commonType
 #include "FindOpenVars.h"           // for findOpenVars
+#include "SpecCost.hpp"             // for SpecCost
 #include "SynTree/LinkageSpec.h"    // for C
 #include "SynTree/Constant.h"       // for Constant
 …
 #include "Tuples/Tuples.h"          // for isTtype
 #include "TypeEnvironment.h"        // for EqvClass, AssertionSet, OpenVarSet
 #include "typeops.h"                // for flatten, occurs, commonType
+#include "typeops.h"                // for flatten, occurs
 namespace ast {
 …
 namespace SymTab {
 class Indexer;
+        class Indexer;
 }  // namespace SymTab
 …
 namespace ResolvExpr {
+// Template Helpers:
+template< typename Iterator1, typename Iterator2 >
+bool unifyList( Iterator1 list1Begin, Iterator1 list1End, Iterator2 list2Begin, Iterator2 list2End, TypeEnvironment &env, AssertionSet &needAssertions, AssertionSet &haveAssertions, OpenVarSet &openVars, const SymTab::Indexer &indexer, std::list< Type* > &commonTypes ) {
+        for ( ; list1Begin != list1End && list2Begin != list2End; ++list1Begin, ++list2Begin ) {
+                Type *commonType = 0;
+                if ( ! unify( *list1Begin, *list2Begin, env, needAssertions, haveAssertions, openVars, indexer, commonType ) ) {
+                        return false;
+                } // if
+                commonTypes.push_back( commonType );
+        } // for
+        return ( list1Begin == list1End && list2Begin == list2End );
+}
+template< typename Iterator1, typename Iterator2 >
+bool unifyList( Iterator1 list1Begin, Iterator1 list1End, Iterator2 list2Begin, Iterator2 list2End, TypeEnvironment &env, AssertionSet &needAssertions, AssertionSet &haveAssertions, OpenVarSet &openVars, const SymTab::Indexer &indexer ) {
+        std::list< Type* > commonTypes;
+        if ( unifyList( list1Begin, list1End, list2Begin, list2End, env, needAssertions, haveAssertions,  openVars, indexer, commonTypes ) ) {
+                deleteAll( commonTypes );
+                return true;
+        } else {
+                return false;
+        } // if
+}
         struct Unify_old : public WithShortCircuiting {
 …
                 const ast::Type * type1, const ast::Type * type2, ast::TypeEnvironment & env,
                 ast::AssertionSet & need, ast::AssertionSet & have, const ast::OpenVarSet & open,
                 WidenMode widen, const ast::SymbolTable & symtab );
+                WidenMode widen );
         bool typesCompatible( const Type * first, const Type * second, const SymTab::Indexer & indexer, const TypeEnvironment & env ) {
 …
         bool typesCompatible(
                         const ast::Type * first, const ast::Type * second, const ast::SymbolTable & symtab,
+                        const ast::Type * first, const ast::Type * second,
                         const ast::TypeEnvironment & env ) {
                 ast::TypeEnvironment newEnv;
 …
                 findOpenVars( newSecond, open, closed, need, have, newEnv, FirstOpen );
                 return unifyExact(newFirst, newSecond, newEnv, need, have, open, noWiden(), symtab );
+                return unifyExact(newFirst, newSecond, newEnv, need, have, open, noWiden() );
+        }
 …
         bool typesCompatibleIgnoreQualifiers(
                         const ast::Type * first, const ast::Type * second, const ast::SymbolTable & symtab,
+                        const ast::Type * first, const ast::Type * second,
                         const ast::TypeEnvironment & env ) {
                 ast::TypeEnvironment newEnv;
 …
                         subFirst,
                         subSecond,
                         newEnv, need, have, open, noWiden(), symtab );
+                        newEnv, need, have, open, noWiden() );
+        }
 …
                 const ast::OpenVarSet & open;
                 WidenMode widen;
-                const ast::SymbolTable & symtab;
         public:
                 static size_t traceId;
 …
                 Unify_new(
                         const ast::Type * type2, ast::TypeEnvironment & env, ast::AssertionSet & need,
+                        ast::AssertionSet & have, const ast::OpenVarSet & open, WidenMode widen,
+                        const ast::SymbolTable & symtab )
+                        ast::AssertionSet & have, const ast::OpenVarSet & open, WidenMode widen )
                 : type2(type2), tenv(env), need(need), have(have), open(open), widen(widen),
                   symtab(symtab), result(false) {}
+                result(false) {}
                 void previsit( const ast::Node * ) { visit_children = false; }
 …
                                 result = unifyExact(
                                         pointer->base, pointer2->base, tenv, need, have, open,
                                         noWiden(), symtab );
+                                        noWiden());
+                        }
+                }
 …
                         result = unifyExact(
+                                array->base, array2->base, tenv, need, have, open, noWiden(),
+                                symtab );
+                                array->base, array2->base, tenv, need, have, open, noWiden());
+                }
 …
                         if ( auto ref2 = dynamic_cast< const ast::ReferenceType * >( type2 ) ) {
                                 result = unifyExact(
+                                        ref->base, ref2->base, tenv, need, have, open, noWiden(),
+                                        symtab );
+                                        ref->base, ref2->base, tenv, need, have, open, noWiden());
+                        }
+                }
 …
                 static bool unifyTypeList(
                         Iter crnt1, Iter end1, Iter crnt2, Iter end2, ast::TypeEnvironment & env,
+                        ast::AssertionSet & need, ast::AssertionSet & have, const ast::OpenVarSet & open,
+                        const ast::SymbolTable & symtab
+                        ast::AssertionSet & need, ast::AssertionSet & have, const ast::OpenVarSet & open
                 ) {
                         while ( crnt1 != end1 && crnt2 != end2 ) {
 …
                                         return unifyExact(
                                                 t1, tupleFromTypes( crnt2, end2 ), env, need, have, open,
                                                 noWiden(), symtab );
+                                                noWiden() );
                                 } else if ( ! isTuple1 && isTuple2 ) {
                                         // combine remainder of list1, then unify
                                         return unifyExact(
                                                 tupleFromTypes( crnt1, end1 ), t2, env, need, have, open,
                                                 noWiden(), symtab );
+                                                noWiden() );
+                                }
                                 if ( ! unifyExact(
                                         t1, t2, env, need, have, open, noWiden(), symtab )
+                                        t1, t2, env, need, have, open, noWiden() )
                                 ) return false;
 …
                                 return unifyExact(
                                         t1, tupleFromTypes( crnt2, end2 ), env, need, have, open,
                                         noWiden(), symtab );
+                                        noWiden() );
                         } else if ( crnt2 != end2 ) {
                                 // try unifying empty tuple with ttype
 …
                                 return unifyExact(
                                         tupleFromTypes( crnt1, end1 ), t2, env, need, have, open,
                                         noWiden(), symtab );
+                                        noWiden() );
+                        }
 …
                         const std::vector< ast::ptr< ast::Type > > & list2,
                         ast::TypeEnvironment & env, ast::AssertionSet & need, ast::AssertionSet & have,
                         const ast::OpenVarSet & open, const ast::SymbolTable & symtab
+                        const ast::OpenVarSet & open
                 ) {
                         return unifyTypeList(
+                                list1.begin(), list1.end(), list2.begin(), list2.end(), env, need, have, open,
+                                symtab );
+                                list1.begin(), list1.end(), list2.begin(), list2.end(), env, need, have, open);
+                }
 …
                         ) return;
                         if ( ! unifyTypeList( params, params2, tenv, need, have, open, symtab ) ) return;
+                        if ( ! unifyTypeList( params, params2, tenv, need, have, open ) ) return;
                         if ( ! unifyTypeList(
                                 func->returns, func2->returns, tenv, need, have, open, symtab ) ) return;
+                                func->returns, func2->returns, tenv, need, have, open ) ) return;
                         markAssertions( have, need, func );
 …
                         // check that the other type is compatible and named the same
                         auto otherInst = dynamic_cast< const XInstType * >( other );
+                        if (otherInst && inst->name == otherInst->name) this->result = otherInst;
+                        if (otherInst && inst->name == otherInst->name)
+                                this->result = otherInst;
                         return otherInst;
+                }
 …
                                 if ( ! unifyExact(
                                                 pty, pty2, tenv, need, have, open, noWiden(), symtab ) ) {
+                                                pty, pty2, tenv, need, have, open, noWiden() ) ) {
                                         result = false;
                                         return;
 …
                 void postvisit( const ast::TypeInstType * typeInst ) {
                         // assert( open.find( *typeInst ) == open.end() );
+                        handleRefType( typeInst, type2 );
+                        auto otherInst = dynamic_cast< const ast::TypeInstType * >( type2 );
+                        if (otherInst && typeInst->name == otherInst->name)
+                                this->result = otherInst;
+                        // return otherInst;
+                }
 …
                         const std::vector< ast::ptr< ast::Type > > & list1,
                         const std::vector< ast::ptr< ast::Type > > & list2, ast::TypeEnvironment & env,
+                        ast::AssertionSet & need, ast::AssertionSet & have, const ast::OpenVarSet & open,
+                        const ast::SymbolTable & symtab
+                        ast::AssertionSet & need, ast::AssertionSet & have, const ast::OpenVarSet & open
                 ) {
                         auto crnt1 = list1.begin();
 …
                                         return unifyExact(
                                                 t1, tupleFromTypes( list2 ), env, need, have, open,
                                                 noWiden(), symtab );
+                                                noWiden() );
                                 } else if ( ! isTuple1 && isTuple2 ) {
                                         // combine entirety of list1, then unify
                                         return unifyExact(
                                                 tupleFromTypes( list1 ), t2, env, need, have, open,
                                                 noWiden(), symtab );
+                                                noWiden() );
+                                }
                                 if ( ! unifyExact(
                                         t1, t2, env, need, have, open, noWiden(), symtab )
+                                        t1, t2, env, need, have, open, noWiden() )
                                 ) return false;
 …
                                 return unifyExact(
                                                 t1, tupleFromTypes( list2 ), env, need, have, open,
                                                 noWiden(), symtab );
+                                                noWiden() );
                         } else if ( crnt2 != list2.end() ) {
                                 // try unifying empty tuple with ttype
 …
                                 return unifyExact(
                                                 tupleFromTypes( list1 ), t2, env, need, have, open,
                                                 noWiden(), symtab );
+                                                noWiden() );
+                        }
 …
                         auto types2 = flatten( flat2 );
                         result = unifyList( types, types2, tenv, need, have, open, symtab );
+                        result = unifyList( types, types2, tenv, need, have, open );
+                }
 …
                         const ast::ptr<ast::Type> & type1, const ast::ptr<ast::Type> & type2,
                         ast::TypeEnvironment & env, ast::AssertionSet & need, ast::AssertionSet & have,
                         ast::OpenVarSet & open, const ast::SymbolTable & symtab
+                        ast::OpenVarSet & open
         ) {
                 ast::ptr<ast::Type> common;
                 return unify( type1, type2, env, need, have, open, symtab, common );
+                return unify( type1, type2, env, need, have, open, common );
+        }
 …
                         const ast::ptr<ast::Type> & type1, const ast::ptr<ast::Type> & type2,
                         ast::TypeEnvironment & env, ast::AssertionSet & need, ast::AssertionSet & have,
                         ast::OpenVarSet & open, const ast::SymbolTable & symtab, ast::ptr<ast::Type> & common
+                        ast::OpenVarSet & open, ast::ptr<ast::Type> & common
         ) {
                 ast::OpenVarSet closed;
 …
                 findOpenVars( type2, open, closed, need, have, env, FirstOpen );
                 return unifyInexact(
                         type1, type2, env, need, have, open, WidenMode{ true, true }, symtab, common );
+                        type1, type2, env, need, have, open, WidenMode{ true, true }, common );
+        }
 …
                         const ast::Type * type1, const ast::Type * type2, ast::TypeEnvironment & env,
                         ast::AssertionSet & need, ast::AssertionSet & have, const ast::OpenVarSet & open,
                         WidenMode widen, const ast::SymbolTable & symtab
+                        WidenMode widen
         ) {
                 if ( type1->qualifiers != type2->qualifiers ) return false;
 …
                         return env.bindVarToVar(
                                 var1, var2, ast::TypeData{ entry1->second, entry2->second }, need, have,
                                 open, widen, symtab );
+                                open, widen );
                 } else if ( isopen1 ) {
                         return env.bindVar( var1, type2, entry1->second, need, have, open, widen, symtab );
+                        return env.bindVar( var1, type2, entry1->second, need, have, open, widen );
                 } else if ( isopen2 ) {
                         return env.bindVar( var2, type1, entry2->second, need, have, open, widen, symtab );
 …
                         return env.bindVarToVar(
                                 var1, var2, ast::TypeData{ var1->base->kind, var1->base->sized||var2->base->sized }, need, have,
                                 open, widen, symtab );
+                                open, widen );
                 } else if ( isopen1 ) {
                         return env.bindVar( var1, type2, ast::TypeData{var1->base}, need, have, open, widen, symtab );
+                        return env.bindVar( var1, type2, ast::TypeData{var1->base}, need, have, open, widen );
                 } else if ( isopen2 ) {
                         return env.bindVar( var2, type1, ast::TypeData{var2->base}, need, have, open, widen, symtab );
+                        return env.bindVar( var2, type1, ast::TypeData{var2->base}, need, have, open, widen );
                 }else {
                         return ast::Pass<Unify_new>::read(
                                 type1, type2, env, need, have, open, widen, symtab );
+                                type1, type2, env, need, have, open, widen );
+                }
 …
                         const ast::ptr<ast::Type> & type1, const ast::ptr<ast::Type> & type2,
                         ast::TypeEnvironment & env, ast::AssertionSet & need, ast::AssertionSet & have,
                         const ast::OpenVarSet & open, WidenMode widen, const ast::SymbolTable & symtab,
+                        const ast::OpenVarSet & open, WidenMode widen,
                         ast::ptr<ast::Type> & common
         ) {
 …
                 ast::ptr< ast::Type > t2_(t2);
                 if ( unifyExact( t1, t2, env, need, have, open, widen, symtab ) ) {
+                if ( unifyExact( t1, t2, env, need, have, open, widen ) ) {
                         // if exact unification on unqualified types, try to merge qualifiers
                         if ( q1 == q2 || ( ( q1 > q2 || widen.first ) && ( q2 > q1 || widen.second ) ) ) {
 …
+                        }
                 } else if (( common = commonType( t1, t2, env, need, have, open, widen, symtab ))) {
+                } else if (( common = commonType( t1, t2, env, need, have, open, widen ))) {
                         // no exact unification, but common type
                         auto c = shallowCopy(common.get());

src/ResolvExpr/Unify.h

-              r34b4268
+              r24d6572
 // Author           : Richard C. Bilson
 // Created On       : Sun May 17 13:09:04 2015
 // Last Modified By : Aaron B. Moss
 // Last Modified On : Mon Jun 18 11:58:00 2018
 // Update Count     : 4
+// Last Modified By : Andrew Beach
+// Last Modified On : Tue Jan 17 11:12:00 2023
+// Update Count     : 5
 //
 …
 namespace ResolvExpr {
-        bool unify( Type *type1, Type *type2, TypeEnvironment &env, AssertionSet &needAssertions, AssertionSet &haveAssertions, OpenVarSet &openVars, const SymTab::Indexer &indexer );
-        bool unify( Type *type1, Type *type2, TypeEnvironment &env, AssertionSet &needAssertions, AssertionSet &haveAssertions, OpenVarSet &openVars, const SymTab::Indexer &indexer, Type *&commonType );
-        bool unifyExact( Type *type1, Type *type2, TypeEnvironment &env, AssertionSet &needAssertions, AssertionSet &haveAssertions, OpenVarSet &openVars, const SymTab::Indexer &indexer );
-        bool unifyInexact( Type *type1, Type *type2, TypeEnvironment &env, AssertionSet &needAssertions, AssertionSet &haveAssertions, const OpenVarSet &openVars, WidenMode widen, const SymTab::Indexer &indexer, Type *&common );
+        template< typename Iterator1, typename Iterator2 >
+        bool unifyList( Iterator1 list1Begin, Iterator1 list1End, Iterator2 list2Begin, Iterator2 list2End, TypeEnvironment &env, AssertionSet &needAssertions, AssertionSet &haveAssertions, OpenVarSet &openVars, const SymTab::Indexer &indexer, std::list< Type* > &commonTypes ) {
+                for ( ; list1Begin != list1End && list2Begin != list2End; ++list1Begin, ++list2Begin ) {
+                        Type *commonType = 0;
+                        if ( ! unify( *list1Begin, *list2Begin, env, needAssertions, haveAssertions, openVars, indexer, commonType ) ) {
+                                return false;
+                        } // if
+                        commonTypes.push_back( commonType );
+                } // for
+                if ( list1Begin != list1End || list2Begin != list2End ) {
+                        return false;
+                } else {
+                        return true;
+                } // if
+        }
+bool unify( Type *type1, Type *type2, TypeEnvironment &env, AssertionSet &needAssertions, AssertionSet &haveAssertions, OpenVarSet &openVars, const SymTab::Indexer &indexer );
+bool unify( Type *type1, Type *type2, TypeEnvironment &env, AssertionSet &needAssertions, AssertionSet &haveAssertions, OpenVarSet &openVars, const SymTab::Indexer &indexer, Type *&commonType );
+bool unifyExact( Type *type1, Type *type2, TypeEnvironment &env, AssertionSet &needAssertions, AssertionSet &haveAssertions, OpenVarSet &openVars, const SymTab::Indexer &indexer );
+bool unifyInexact( Type *type1, Type *type2, TypeEnvironment &env, AssertionSet &needAssertions, AssertionSet &haveAssertions, const OpenVarSet &openVars, WidenMode widen, const SymTab::Indexer &indexer, Type *&common );
+        template< typename Iterator1, typename Iterator2 >
+        bool unifyList( Iterator1 list1Begin, Iterator1 list1End, Iterator2 list2Begin, Iterator2 list2End, TypeEnvironment &env, AssertionSet &needAssertions, AssertionSet &haveAssertions, OpenVarSet &openVars, const SymTab::Indexer &indexer ) {
+                std::list< Type* > commonTypes;
+                if ( unifyList( list1Begin, list1End, list2Begin, list2End, env, needAssertions, haveAssertions, openVars, indexer, commonTypes ) ) {
+                        deleteAll( commonTypes );
+                        return true;
+                } else {
+                        return false;
+                } // if
+        }
+bool typesCompatible( const Type *, const Type *, const SymTab::Indexer & indexer, const TypeEnvironment & env );
+bool typesCompatibleIgnoreQualifiers( const Type *, const Type *, const SymTab::Indexer & indexer, const TypeEnvironment & env );
+        bool unify(
                 const ast::ptr<ast::Type> & type1, const ast::ptr<ast::Type> & type2,
                 ast::TypeEnvironment & env, ast::AssertionSet & need, ast::AssertionSet & have,
+                ast::OpenVarSet & open, const ast::SymbolTable & symtab );
+inline bool typesCompatible( const Type * t1, const Type * t2, const SymTab::Indexer & indexer ) {
+        TypeEnvironment env;
+        return typesCompatible( t1, t2, indexer, env );
+}
+        bool unify(
                 const ast::ptr<ast::Type> & type1, const ast::ptr<ast::Type> & type2,
                 ast::TypeEnvironment & env, ast::AssertionSet & need, ast::AssertionSet & have,
+                ast::OpenVarSet & open, const ast::SymbolTable & symtab, ast::ptr<ast::Type> & common );
+inline bool typesCompatibleIgnoreQualifiers( const Type * t1, const Type * t2, const SymTab::Indexer & indexer ) {
+        TypeEnvironment env;
+        return typesCompatibleIgnoreQualifiers( t1, t2, indexer, env );
+}
+        bool unifyExact(
                 const ast::Type * type1, const ast::Type * type2, ast::TypeEnvironment & env,
                 ast::AssertionSet & need, ast::AssertionSet & have, const ast::OpenVarSet & open,
                 WidenMode widen, const ast::SymbolTable & symtab );
+bool unify(
+        const ast::ptr<ast::Type> & type1, const ast::ptr<ast::Type> & type2,
+        ast::TypeEnvironment & env, ast::AssertionSet & need, ast::AssertionSet & have,
+        ast::OpenVarSet & open );
+        bool unifyInexact(
+                const ast::ptr<ast::Type> & type1, const ast::ptr<ast::Type> & type2,
+                ast::TypeEnvironment & env, ast::AssertionSet & need, ast::AssertionSet & have,
+                const ast::OpenVarSet & open, WidenMode widen, const ast::SymbolTable & symtab,
+                ast::ptr<ast::Type> & common );
+bool unify(
+        const ast::ptr<ast::Type> & type1, const ast::ptr<ast::Type> & type2,
+        ast::TypeEnvironment & env, ast::AssertionSet & need, ast::AssertionSet & have,
+        ast::OpenVarSet & open, ast::ptr<ast::Type> & common );
+bool unifyExact(
+        const ast::Type * type1, const ast::Type * type2, ast::TypeEnvironment & env,
+        ast::AssertionSet & need, ast::AssertionSet & have, const ast::OpenVarSet & open,
+        WidenMode widen );
+bool unifyInexact(
+        const ast::ptr<ast::Type> & type1, const ast::ptr<ast::Type> & type2,
+        ast::TypeEnvironment & env, ast::AssertionSet & need, ast::AssertionSet & have,
+        const ast::OpenVarSet & open, WidenMode widen,
+        ast::ptr<ast::Type> & common );
+bool typesCompatible(
+        const ast::Type *, const ast::Type *,
+        const ast::TypeEnvironment & env = {} );
+bool typesCompatibleIgnoreQualifiers(
+        const ast::Type *, const ast::Type *,
+        const ast::TypeEnvironment & env = {} );
+/// 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 returns in a `FunctionType`.
+ast::ptr<ast::Type> extractResultType( const ast::FunctionType * func );
+std::vector<ast::ptr<ast::Type>> flattenList(
+        const std::vector<ast::ptr<ast::Type>> & src, ast::TypeEnvironment & env
+);
 } // namespace ResolvExpr

src/ResolvExpr/WidenMode.h

-              r34b4268
+              r24d6572
         struct WidenMode {
                 WidenMode( bool first, bool second ): first( first ), second( second ) {}
                 WidenMode &operator|=( const WidenMode &other ) {
                         first |= other.first; second |= other.second; return *this;
 …
                         WidenMode newWM( *this ); newWM &= other; return newWM;
+                }
                 operator bool() { return first && second; }

src/ResolvExpr/module.mk

-              r34b4268
+              r24d6572
 SRC_RESOLVEXPR = \
       ResolvExpr/AdjustExprType.cc \
+      ResolvExpr/AdjustExprType.hpp \
       ResolvExpr/Alternative.cc \
       ResolvExpr/AlternativeFinder.cc \
 …
       ResolvExpr/Candidate.hpp \
       ResolvExpr/CastCost.cc \
+      ResolvExpr/CastCost.hpp \
       ResolvExpr/CommonType.cc \
+      ResolvExpr/CommonType.hpp \
       ResolvExpr/ConversionCost.cc \
       ResolvExpr/ConversionCost.h \
 …
       ResolvExpr/Occurs.cc \
       ResolvExpr/PolyCost.cc \
+      ResolvExpr/PolyCost.hpp \
       ResolvExpr/PtrsAssignable.cc \
+      ResolvExpr/PtrsAssignable.hpp \
       ResolvExpr/PtrsCastable.cc \
+      ResolvExpr/PtrsCastable.hpp \
       ResolvExpr/RenameVars.cc \
       ResolvExpr/RenameVars.h \
 …
       ResolvExpr/SatisfyAssertions.hpp \
       ResolvExpr/SpecCost.cc \
+      ResolvExpr/SpecCost.hpp \
       ResolvExpr/TypeEnvironment.cc \
       ResolvExpr/TypeEnvironment.h \

src/ResolvExpr/typeops.h

-              r34b4268
+              r24d6572
 // Created On       : Sun May 17 07:28:22 2015
 // Last Modified By : Andrew Beach
 // Last Modified On : Tue Oct  1 09:45:00 2019
 // Update Count     : 6
+// Last Modified On : Wed Jan 18 11:54:00 2023
+// Update Count     : 7
 //
 …
 #include <vector>
-#include "Cost.h"
-#include "TypeEnvironment.h"
-#include "WidenMode.h"
-#include "AST/Fwd.hpp"
-#include "AST/Node.hpp"
-#include "AST/SymbolTable.hpp"
 #include "AST/Type.hpp"
-#include "AST/TypeEnvironment.hpp"
-#include "SynTree/SynTree.h"
 #include "SynTree/Type.h"
 …
 namespace ResolvExpr {
+        class TypeEnvironment;
         // combos: takes a list of sets and returns a set of lists representing every possible way of forming a list by
         // picking one element out of each set
 …
+        }
-        // in AdjustExprType.cc
-        /// Replaces array types with the equivalent pointer, and function types with a pointer-to-function
-        void adjustExprType( Type *& type, const TypeEnvironment & env, const SymTab::Indexer & indexer );
-        /// Replaces array types with the equivalent pointer, and function types with a pointer-to-function using empty TypeEnvironment and Indexer
-        void adjustExprType( Type *& type );
-        template< typename ForwardIterator >
-        void adjustExprTypeList( ForwardIterator begin, ForwardIterator end, const TypeEnvironment & env, const SymTab::Indexer & indexer ) {
-                while ( begin != end ) {
-                        adjustExprType( *begin++, env, indexer );
-                } // while
+        }
-        /// Replaces array types with equivalent pointer, and function types with a pointer-to-function
-        const ast::Type * adjustExprType(
-                const ast::Type * type, const ast::TypeEnvironment & env, const ast::SymbolTable & symtab );
-        // in CastCost.cc
-        Cost castCost( const Type * src, const Type * dest, bool srcIsLvalue,
-                const SymTab::Indexer & indexer, const TypeEnvironment & env );
-        Cost castCost(
-                const ast::Type * src, const ast::Type * dst, bool srcIsLvalue,
-                const ast::SymbolTable & symtab, const ast::TypeEnvironment & env );
-        // in ConversionCost.cc
-        Cost conversionCost( const Type * src, const Type * dest, bool srcIsLvalue,
-                const SymTab::Indexer & indexer, const TypeEnvironment & env );
-        Cost conversionCost(
-                const ast::Type * src, const ast::Type * dst, bool srcIsLvalue,
-                const ast::SymbolTable & symtab, const ast::TypeEnvironment & env );
-        // in AlternativeFinder.cc
-        Cost computeConversionCost( Type * actualType, Type * formalType, bool actualIsLvalue,
-                const SymTab::Indexer & indexer, const TypeEnvironment & env );
-        // in PtrsAssignable.cc
-        int ptrsAssignable( const Type * src, const Type * dest, const TypeEnvironment & env );
-        int ptrsAssignable( const ast::Type * src, const ast::Type * dst,
-                const ast::TypeEnvironment & env );
-        // in PtrsCastable.cc
-        int ptrsCastable( const Type * src, const Type * dest, const TypeEnvironment & env, const SymTab::Indexer & indexer );
-        int ptrsCastable(
-                const ast::Type * src, const ast::Type * dst, const ast::SymbolTable & symtab,
-                const ast::TypeEnvironment & env );
-        // in Unify.cc
-        bool typesCompatible( const Type *, const Type *, const SymTab::Indexer & indexer, const TypeEnvironment & env );
-        bool typesCompatibleIgnoreQualifiers( const Type *, const Type *, const SymTab::Indexer & indexer, const TypeEnvironment & env );
-        inline bool typesCompatible( const Type * t1, const Type * t2, const SymTab::Indexer & indexer ) {
-                TypeEnvironment env;
-                return typesCompatible( t1, t2, indexer, env );
+        }
-        inline bool typesCompatibleIgnoreQualifiers( const Type * t1, const Type * t2, const SymTab::Indexer & indexer ) {
-                TypeEnvironment env;
-                return typesCompatibleIgnoreQualifiers( t1, t2, indexer, env );
+        }
-        bool typesCompatible(
-                const ast::Type *, const ast::Type *, const ast::SymbolTable & symtab = {},
-                const ast::TypeEnvironment & env = {} );
-        bool typesCompatibleIgnoreQualifiers(
-                const ast::Type *, const ast::Type *, const ast::SymbolTable &,
-                const ast::TypeEnvironment & env = {} );
-        /// 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 );
-        ast::ptr< ast::Type > commonType(
-                const ast::ptr< ast::Type > & type1, const ast::ptr< ast::Type > & type2,
-                        ast::TypeEnvironment & env, ast::AssertionSet & need, ast::AssertionSet & have,
-                        const ast::OpenVarSet & open, WidenMode widen, const ast::SymbolTable & symtab
-        );
-        // in Unify.cc
-        std::vector< ast::ptr< ast::Type > > flattenList(
-                const std::vector< ast::ptr< ast::Type > > & src, ast::TypeEnvironment & env
-        );
-        // in PolyCost.cc
-        int polyCost( Type * type, const TypeEnvironment & env, const SymTab::Indexer & indexer );
-        int polyCost(
-                const ast::Type * type, const ast::SymbolTable & symtab, const ast::TypeEnvironment & env );
-        // in SpecCost.cc
-        int specCost( Type * type );
-        int specCost( const ast::Type * type );
         // in Occurs.cc
         bool occurs( const Type * type, const std::string & varName, const TypeEnvironment & env );
 …
                 return false;
+        }
-        // in AlternativeFinder.cc
-        void referenceToRvalueConversion( Expression *& expr, Cost & cost );
-        // in CandidateFinder.cpp
-        const ast::Expr * referenceToRvalueConversion( const ast::Expr * expr, Cost & cost );
         /// flatten tuple type into list of types
 …
+                }
                 return new ast::TupleType{ std::move(types) };
+        }
 …
                 return tupleFromTypes( tys.begin(), tys.end() );
+        }
         // in TypeEnvironment.cc

src/SymTab/Autogen.cc

-              r34b4268
+              r24d6572
 // Created On       : Thu Mar 03 15:45:56 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Apr 27 14:39:06 2018
 // Update Count     : 63
+// Last Modified On : Fri Apr 14 15:03:00 2023
+// Update Count     : 64
 //
 …
+        }
-        bool isUnnamedBitfield( const ast::ObjectDecl * obj ) {
-                return obj && obj->name.empty() && obj->bitfieldWidth;
+        }
         /// inserts a forward declaration for functionDecl into declsToAdd
         void addForwardDecl( FunctionDecl * functionDecl, std::list< Declaration * > & declsToAdd ) {
 …
+        }
-        // shallow copy the pointer list for return
-        std::vector<ast::ptr<ast::TypeDecl>> getGenericParams (const ast::Type * t) {
-                if (auto structInst = dynamic_cast<const ast::StructInstType*>(t)) {
-                        return structInst->base->params;
+                }
-                if (auto unionInst = dynamic_cast<const ast::UnionInstType*>(t)) {
-                        return unionInst->base->params;
+                }
-                return {};
+        }
         /// given type T, generate type of default ctor/dtor, i.e. function type void (*) (T *)
         FunctionType * genDefaultType( Type * paramType, bool maybePolymorphic ) {
 …
                 ftype->parameters.push_back( dstParam );
                 return ftype;
+        }
-        /// Given type T, generate type of default ctor/dtor, i.e. function type void (*) (T &).
-        ast::FunctionDecl * genDefaultFunc(const CodeLocation loc, const std::string fname, const ast::Type * paramType, bool maybePolymorphic) {
-                std::vector<ast::ptr<ast::TypeDecl>> typeParams;
-                if (maybePolymorphic) typeParams = getGenericParams(paramType);
-                auto dstParam = new ast::ObjectDecl(loc, "_dst", new ast::ReferenceType(paramType), nullptr, {}, ast::Linkage::Cforall);
-                return new ast::FunctionDecl(loc, fname, std::move(typeParams), {dstParam}, {}, new ast::CompoundStmt(loc), {}, ast::Linkage::Cforall);
+        }

src/SymTab/Autogen.h

-              r34b4268
+              r24d6572
 // Author           : Rob Schluntz
 // Created On       : Sun May 17 21:53:34 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Dec 13 16:38:06 2019
 // Update Count     : 16
+// Last Modified By : Andrew Beach
+// Last Modified On : Fri Apr 14 15:06:00 2023
+// Update Count     : 17
 //
 …
 #include <string>                 // for string
-#include "AST/Decl.hpp"
-#include "AST/Expr.hpp"
-#include "AST/Init.hpp"
-#include "AST/Node.hpp"
-#include "AST/Stmt.hpp"
-#include "AST/Type.hpp"
 #include "CodeGen/OperatorTable.h"
 #include "Common/UniqueName.h"    // for UniqueName
 …
         /// returns true if obj's name is the empty string and it has a bitfield width
         bool isUnnamedBitfield( ObjectDecl * obj );
-        bool isUnnamedBitfield( const ast::ObjectDecl * obj );
         /// generate the type of an assignment function for paramType.
 …
         FunctionType * genDefaultType( Type * paramType, bool maybePolymorphic = true );
-        ast::FunctionDecl * genDefaultFunc(const CodeLocation loc, const std::string fname, const ast::Type * paramType, bool maybePolymorphic = true);
         /// generate the type of a copy constructor for paramType.
         /// maybePolymorphic is true if the resulting FunctionType is allowed to be polymorphic
         FunctionType * genCopyType( Type * paramType, bool maybePolymorphic = true );
-        /// Enum for loop direction
-        enum LoopDirection { LoopBackward, LoopForward };
         /// inserts into out a generated call expression to function fname with arguments dstParam and srcParam. Intended to be used with generated ?=?, ?{}, and ^?{} calls.
         template< typename OutputIterator >
         Statement * genCall( InitTweak::InitExpander_old & srcParam, Expression * dstParam, const std::string & fname, OutputIterator out, Type * type, Type * addCast = nullptr, bool forward = true );
-        template< typename OutIter >
-        ast::ptr< ast::Stmt > genCall(
-                InitTweak::InitExpander_new & srcParam, const ast::Expr * dstParam,
-                const CodeLocation & loc, const std::string & fname, OutIter && out,
-                const ast::Type * type, const ast::Type * addCast, LoopDirection forward = LoopForward );
         /// inserts into out a generated call expression to function fname with arguments dstParam and srcParam. Should only be called with non-array types.
 …
                 *out++ = new ExprStmt( fExpr );
-                srcParam.clearArrayIndices();
-                return listInit;
+        }
-        /// inserts into out a generated call expression to function fname with arguments dstParam and
-        /// srcParam. Should only be called with non-array types.
-        /// optionally returns a statement which must be inserted prior to the containing loop, if
-        /// there is one
-        template< typename OutIter >
-        ast::ptr< ast::Stmt > genScalarCall(
-                InitTweak::InitExpander_new & srcParam, const ast::Expr * dstParam,
-                const CodeLocation & loc, std::string fname, OutIter && out, const ast::Type * type,
-                const ast::Type * addCast = nullptr
-        ) {
-                bool isReferenceCtorDtor = false;
-                if ( dynamic_cast< const ast::ReferenceType * >( type ) && CodeGen::isCtorDtor( fname ) ) {
-                        // reference constructors are essentially application of the rebind operator.
-                        // apply & to both arguments, do not need a cast
-                        fname = "?=?";
-                        dstParam = new ast::AddressExpr{ dstParam };
-                        addCast = nullptr;
-                        isReferenceCtorDtor = true;
+                }
-                // want to be able to generate assignment, ctor, and dtor generically, so fname is one of
-                // "?=?", "?{}", or "^?{}"
-                ast::UntypedExpr * fExpr = new ast::UntypedExpr{ loc, new ast::NameExpr{ loc, fname } };
-                if ( addCast ) {
-                        // cast to T& with qualifiers removed, so that qualified objects can be constructed and
-                        // destructed with the same functions as non-qualified objects. Unfortunately, lvalue
-                        // is considered a qualifier - for AddressExpr to resolve, its argument must have an
-                        // lvalue-qualified type, so remove all qualifiers except lvalue.
-                        // xxx -- old code actually removed lvalue too...
-                        ast::ptr< ast::Type > guard = addCast;  // prevent castType from mutating addCast
-                        ast::ptr< ast::Type > castType = addCast;
-                        ast::remove_qualifiers(
-                                castType,
-                                ast::CV::Const | ast::CV::Volatile | ast::CV::Restrict | ast::CV::Atomic );
-                        dstParam = new ast::CastExpr{ dstParam, new ast::ReferenceType{ castType } };
+                }
-                fExpr->args.emplace_back( dstParam );
-                ast::ptr<ast::Stmt> listInit = srcParam.buildListInit( fExpr );
-                // fetch next set of arguments
-                ++srcParam;
-                // return if adding reference fails -- will happen on default ctor and dtor
-                if ( isReferenceCtorDtor && ! srcParam.addReference() ) return listInit;
-                std::vector< ast::ptr< ast::Expr > > args = *srcParam;
-                splice( fExpr->args, args );
-                *out++ = new ast::ExprStmt{ loc, fExpr };
                 srcParam.clearArrayIndices();
 …
+        }
-        /// Store in out a loop which calls fname on each element of the array with srcParam and
-        /// dstParam as arguments. If forward is true, loop goes from 0 to N-1, else N-1 to 0
-        template< typename OutIter >
-        void genArrayCall(
-                InitTweak::InitExpander_new & srcParam, const ast::Expr * dstParam,
-                const CodeLocation & loc, const std::string & fname, OutIter && out,
-                const ast::ArrayType * array, const ast::Type * addCast = nullptr,
-                LoopDirection forward = LoopForward
-        ) {
-                static UniqueName indexName( "_index" );
-                // for a flexible array member nothing is done -- user must define own assignment
-                if ( ! array->dimension ) return;
-                if ( addCast ) {
-                        // peel off array layer from cast
-                        addCast = strict_dynamic_cast< const ast::ArrayType * >( addCast )->base;
+                }
-                ast::ptr< ast::Expr > begin, end;
-                std::string cmp, update;
-                if ( forward ) {
-                        // generate: for ( int i = 0; i < N; ++i )
-                        begin = ast::ConstantExpr::from_int( loc, 0 );
-                        end = array->dimension;
-                        cmp = "?<?";
-                        update = "++?";
-                } else {
-                        // generate: for ( int i = N-1; i >= 0; --i )
-                        begin = ast::UntypedExpr::createCall( loc, "?-?",
-                                { array->dimension, ast::ConstantExpr::from_int( loc, 1 ) } );
-                        end = ast::ConstantExpr::from_int( loc, 0 );
-                        cmp = "?>=?";
-                        update = "--?";
+                }
-                ast::ptr< ast::DeclWithType > index = new ast::ObjectDecl{
-                        loc, indexName.newName(), new ast::BasicType{ ast::BasicType::SignedInt },
-                        new ast::SingleInit{ loc, begin } };
-                ast::ptr< ast::Expr > indexVar = new ast::VariableExpr{ loc, index };
-                ast::ptr< ast::Expr > cond = ast::UntypedExpr::createCall(
-                        loc, cmp, { indexVar, end } );
-                ast::ptr< ast::Expr > inc = ast::UntypedExpr::createCall(
-                        loc, update, { indexVar } );
-                ast::ptr< ast::Expr > dstIndex = ast::UntypedExpr::createCall(
-                        loc, "?[?]", { dstParam, indexVar } );
-                // srcParam must keep track of the array indices to build the source parameter and/or
-                // array list initializer
-                srcParam.addArrayIndex( indexVar, array->dimension );
-                // for stmt's body, eventually containing call
-                ast::CompoundStmt * body = new ast::CompoundStmt{ loc };
-                ast::ptr< ast::Stmt > listInit = genCall(
-                        srcParam, dstIndex, loc, fname, std::back_inserter( body->kids ), array->base, addCast,
-                        forward );
-                // block containing the stmt and index variable
-                ast::CompoundStmt * block = new ast::CompoundStmt{ loc };
-                block->push_back( new ast::DeclStmt{ loc, index } );
-                if ( listInit ) { block->push_back( listInit ); }
-                block->push_back( new ast::ForStmt{ loc, {}, cond, inc, body } );
-                *out++ = block;
+        }
         template< typename OutputIterator >
         Statement * genCall( InitTweak::InitExpander_old & srcParam, Expression * dstParam, const std::string & fname, OutputIterator out, Type * type, Type * addCast, bool forward ) {
 …
                 } else {
                         return genScalarCall( srcParam, dstParam, fname, out, type, addCast );
+                }
+        }
-        template< typename OutIter >
-        ast::ptr< ast::Stmt > genCall(
-                InitTweak::InitExpander_new & srcParam, const ast::Expr * dstParam,
-                const CodeLocation & loc, const std::string & fname, OutIter && out,
-                const ast::Type * type, const ast::Type * addCast, LoopDirection forward
-        ) {
-                if ( auto at = dynamic_cast< const ast::ArrayType * >( type ) ) {
-                        genArrayCall(
-                                srcParam, dstParam, loc, fname, std::forward< OutIter >(out), at, addCast,
-                                forward );
-                        return {};
-                } else {
-                        return genScalarCall(
-                                srcParam, dstParam, loc, fname, std::forward< OutIter >( out ), type, addCast );
+                }
+        }
 …
+        }
-        static inline ast::ptr< ast::Stmt > genImplicitCall(
-                InitTweak::InitExpander_new & srcParam, const ast::Expr * dstParam,
-                const CodeLocation & loc, const std::string & fname, const ast::ObjectDecl * obj,
-                LoopDirection forward = LoopForward
-        ) {
-                // unnamed bit fields are not copied as they cannot be accessed
-                if ( isUnnamedBitfield( obj ) ) return {};
-                ast::ptr< ast::Type > addCast;
-                if ( (fname == "?{}" || fname == "^?{}") && ( ! obj || ( obj && ! obj->bitfieldWidth ) ) ) {
-                        assert( dstParam->result );
-                        addCast = dstParam->result;
+                }
-                std::vector< ast::ptr< ast::Stmt > > stmts;
-                genCall(
-                        srcParam, dstParam, loc, fname, back_inserter( stmts ), obj->type, addCast, forward );
-                if ( stmts.empty() ) {
-                        return {};
-                } else if ( stmts.size() == 1 ) {
-                        const ast::Stmt * callStmt = stmts.front();
-                        if ( addCast ) {
-                                // implicitly generated ctor/dtor calls should be wrapped so that later passes are
-                                // aware they were generated.
-                                callStmt = new ast::ImplicitCtorDtorStmt{ callStmt->location, callStmt };
+                        }
-                        return callStmt;
-                } else {
-                        assert( false );
-                        return {};
+                }
+        }
 } // namespace SymTab

src/SymTab/FixFunction.cc

r34b4268	r24d6572
21	21	#include "AST/Pass.hpp"
22	22	#include "AST/Type.hpp"
23		#include "Common/utility.h" // for ~~maybeClone,~~ copy
	23	#include "Common/utility.h" // for copy
24	24	#include "SynTree/Declaration.h" // for FunctionDecl, ObjectDecl, Declarati...
25	25	#include "SynTree/Expression.h" // for Expression

src/SymTab/Indexer.cc

-              r34b4268
+              r24d6572
 #include "InitTweak/InitTweak.h"   // for isConstructor, isCopyFunction, isC...
 #include "Mangler.h"               // for Mangler
+#include "ResolvExpr/typeops.h"    // for typesCompatible
+#include "ResolvExpr/AlternativeFinder.h"  // for referenceToRvalueConversion
+#include "ResolvExpr/Unify.h"      // for typesCompatible
 #include "SynTree/LinkageSpec.h"   // for isMangled, isOverridable, Spec
 #include "SynTree/Constant.h"      // for Constant

src/SymTab/Mangler.cc

-              r34b4268
+              r24d6572
 #include "CodeGen/OperatorTable.h"       // for OperatorInfo, operatorLookup
 #include "Common/PassVisitor.h"
+#include "Common/ToString.hpp"           // for toCString
 #include "Common/SemanticError.h"        // for SemanticError
-#include "Common/utility.h"              // for toString
 #include "ResolvExpr/TypeEnvironment.h"  // for TypeEnvironment
 #include "SynTree/LinkageSpec.h"         // for Spec, isOverridable, AutoGen, Int...
 …
                   private:
                         void mangleDecl( const ast::DeclWithType *declaration );
                         void mangleRef( const ast::BaseInstType *refType, std::string prefix );
+                        void mangleRef( const ast::BaseInstType *refType, const std::string & prefix );
                         void printQualifiers( const ast::Type *type );
 …
+                }
-                __attribute__((unused))
-                inline std::vector< ast::ptr< ast::Type > > getTypes( const std::vector< ast::ptr< ast::DeclWithType > > & decls ) {
-                        std::vector< ast::ptr< ast::Type > > ret;
-                        std::transform( decls.begin(), decls.end(), std::back_inserter( ret ),
-                                                        std::mem_fun( &ast::DeclWithType::get_type ) );
-                        return ret;
+                }
                 void Mangler_new::postvisit( const ast::FunctionType * functionType ) {
                         printQualifiers( functionType );
 …
+                }
+                void Mangler_new::mangleRef( const ast::BaseInstType * refType, std::string prefix ) {
+                void Mangler_new::mangleRef(
+                                const ast::BaseInstType * refType, const std::string & prefix ) {
                         printQualifiers( refType );
                         mangleName += prefix + std::to_string( refType->name.length() ) + refType->name;
+                        if ( mangleGenericParams ) {
+                                if ( ! refType->params.empty() ) {
+                                        mangleName += "_";
+                                        for ( const ast::Expr * param : refType->params ) {
+                                                auto paramType = dynamic_cast< const ast::TypeExpr * >( param );
+                                                assertf(paramType, "Aggregate parameters should be type expressions: %s", toCString(param));
+                                                maybeAccept( paramType->type.get(), *visitor );
+                                        }
+                                        mangleName += "_";
+                        if ( mangleGenericParams && ! refType->params.empty() ) {
+                                mangleName += "_";
+                                for ( const ast::Expr * param : refType->params ) {
+                                        auto paramType = dynamic_cast< const ast::TypeExpr * >( param );
+                                        assertf(paramType, "Aggregate parameters should be type expressions: %s", toCString(param));
+                                        maybeAccept( paramType->type.get(), *visitor );
+                                }
+                                mangleName += "_";
+                        }
+                }
 …
+                }
+                // For debugging:
                 __attribute__((unused)) void printVarMap( const std::map< std::string, std::pair< int, int > > &varMap, std::ostream &os ) {
                         for ( std::map< std::string, std::pair< int, int > >::const_iterator i = varMap.begin(); i != varMap.end(); ++i ) {
 …
                         // skip if not including qualifiers
                         if ( typeMode ) return;
+                        if ( auto ptype = dynamic_cast< const ast::FunctionType * >(type) ) {
+                                if ( ! ptype->forall.empty() ) {
+                                        std::list< std::string > assertionNames;
+                                        int dcount = 0, fcount = 0, vcount = 0, acount = 0;
+                                        mangleName += Encoding::forall;
+                                        for ( auto & decl : ptype->forall ) {
+                                                switch ( decl->kind ) {
+                                                  case ast::TypeDecl::Kind::Dtype:
+                                                        dcount++;
+                                                        break;
+                                                  case ast::TypeDecl::Kind::Ftype:
+                                                        fcount++;
+                                                        break;
+                                                  case ast::TypeDecl::Kind::Ttype:
+                                                        vcount++;
+                                                        break;
+                                                  default:
+                                                        assertf( false, "unimplemented kind for type variable %s", SymTab::Mangler::Encoding::typeVariables[decl->kind].c_str() );
+                                                } // switch
+                                                varNums[ decl->name ] = std::make_pair( nextVarNum, (int)decl->kind );
+                                        } // for
+                                        for ( auto & assert : ptype->assertions ) {
+                                                assertionNames.push_back( ast::Pass<Mangler_new>::read(
+                                                        assert->var.get(),
+                                                        mangleOverridable, typeMode, mangleGenericParams, nextVarNum, varNums ) );
+                                                acount++;
+                                        } // for
+                                        mangleName += std::to_string( dcount ) + "_" + std::to_string( fcount ) + "_" + std::to_string( vcount ) + "_" + std::to_string( acount ) + "_";
+                                        for(const auto & a : assertionNames) mangleName += a;
+//                                      std::copy( assertionNames.begin(), assertionNames.end(), std::ostream_iterator< std::string >( mangleName, "" ) );
+                                        mangleName += "_";
+                                } // if
+                        auto funcType = dynamic_cast<const ast::FunctionType *>( type );
+                        if ( funcType && !funcType->forall.empty() ) {
+                                std::list< std::string > assertionNames;
+                                int dcount = 0, fcount = 0, vcount = 0, acount = 0;
+                                mangleName += Encoding::forall;
+                                for ( auto & decl : funcType->forall ) {
+                                        switch ( decl->kind ) {
+                                        case ast::TypeDecl::Dtype:
+                                                dcount++;
+                                                break;
+                                        case ast::TypeDecl::Ftype:
+                                                fcount++;
+                                                break;
+                                        case ast::TypeDecl::Ttype:
+                                                vcount++;
+                                                break;
+                                        default:
+                                                assertf( false, "unimplemented kind for type variable %s", SymTab::Mangler::Encoding::typeVariables[decl->kind].c_str() );
+                                        } // switch
+                                        varNums[ decl->name ] = std::make_pair( nextVarNum, (int)decl->kind );
+                                } // for
+                                for ( auto & assert : funcType->assertions ) {
+                                        assertionNames.push_back( ast::Pass<Mangler_new>::read(
+                                                assert->var.get(),
+                                                mangleOverridable, typeMode, mangleGenericParams, nextVarNum, varNums ) );
+                                        acount++;
+                                } // for
+                                mangleName += std::to_string( dcount ) + "_" + std::to_string( fcount ) + "_" + std::to_string( vcount ) + "_" + std::to_string( acount ) + "_";
+                                for ( const auto & a : assertionNames ) mangleName += a;
+                                mangleName += "_";
                         } // if
                         if ( ! inFunctionType ) {

src/SymTab/Validate.cc

-              r34b4268
+              r24d6572
 #include "Common/ScopedMap.h"          // for ScopedMap
 #include "Common/SemanticError.h"      // for SemanticError
+#include "Common/ToString.hpp"         // for toCString
 #include "Common/UniqueName.h"         // for UniqueName
 #include "Common/utility.h"            // for operator+, cloneAll, deleteAll
+#include "Common/utility.h"            // for cloneAll, deleteAll
 #include "CompilationState.h"          // skip some passes in new-ast build
 #include "Concurrency/Keywords.h"      // for applyKeywords
 …
 #include "InitTweak/GenInit.h"         // for fixReturnStatements
 #include "InitTweak/InitTweak.h"       // for isCtorDtorAssign
+#include "ResolvExpr/typeops.h"        // for typesCompatible
+#include "ResolvExpr/typeops.h"        // for extractResultType
+#include "ResolvExpr/Unify.h"          // for typesCompatible
 #include "ResolvExpr/Resolver.h"       // for findSingleExpression
 #include "ResolvExpr/ResolveTypeof.h"  // for resolveTypeof
 …
         void ReplaceTypedef::premutate( TypeDecl * typeDecl ) {
+                TypedefMap::iterator i = typedefNames.find( typeDecl->name );
+                if ( i != typedefNames.end() ) {
+                        typedefNames.erase( i ) ;
+                } // if
+                typedefNames.erase( typeDecl->name );
                 typedeclNames.insert( typeDecl->name, typeDecl );
+        }

src/SymTab/ValidateType.cc

r34b4268	r24d6572
18	18	#include "CodeGen/OperatorTable.h"
19	19	#include "Common/PassVisitor.h"
	20	#include "Common/ToString.hpp"
20	21	#include "SymTab/FixFunction.h"
21	22	#include "SynTree/Declaration.h"

src/SymTab/module.mk

r34b4268	r24d6572
20	20	SymTab/FixFunction.cc \
21	21	SymTab/FixFunction.h \
	22	SymTab/GenImplicitCall.cpp \
	23	SymTab/GenImplicitCall.hpp \
22	24	SymTab/Indexer.cc \
23	25	SymTab/Indexer.h \

src/SynTree/AggregateDecl.cc

r34b4268	r24d6572
19	19
20	20	#include "Attribute.h" // for Attribute
	21	#include "Common/Eval.h" // for eval
21	22	#include "Common/utility.h" // for printAll, cloneAll, deleteAll
22	23	#include "Declaration.h" // for AggregateDecl, TypeDecl, Declaration

src/SynTree/ApplicationExpr.cc

-              r34b4268
+              r24d6572
 // file "LICENCE" distributed with Cforall.
 //
 // ApplicationExpr.cc.cc --
+// ApplicationExpr.cc --
 //
 // Author           : Richard C. Bilson
 …
 #include "Expression.h"          // for ParamEntry, ApplicationExpr, Expression
 #include "InitTweak/InitTweak.h" // for getFunction
 #include "ResolvExpr/typeops.h"  // for extractResultType
+#include "ResolvExpr/Unify.h"    // for extractResultType
 #include "Type.h"                // for Type, PointerType, FunctionType

src/SynTree/BasicType.cc

-              r34b4268
+              r24d6572
+}
-bool BasicType::isWholeNumber() const {
-        return kind == Bool ||
-                kind ==Char ||
-                kind == SignedChar ||
-                kind == UnsignedChar ||
-                kind == ShortSignedInt ||
-                kind == ShortUnsignedInt ||
-                kind == SignedInt ||
-                kind == UnsignedInt ||
-                kind == LongSignedInt ||
-                kind == LongUnsignedInt ||
-                kind == LongLongSignedInt ||
-                kind ==LongLongUnsignedInt ||
-                kind == SignedInt128 ||
-                kind == UnsignedInt128;
+}
 bool BasicType::isInteger() const {
         return kind <= UnsignedInt128;

src/SynTree/FunctionDecl.cc

-              r34b4268
+              r24d6572
         } // if
+        if ( !withExprs.empty() ) {
+                os << indent << "... with clause" << std::endl;
+                os << indent + 1;
+                printAll( withExprs, os, indent + 1 );
+        }
         if ( statements ) {
                 os << indent << "... with body" << endl << indent+1;

src/SynTree/Type.cc

-              r34b4268
+              r24d6572
 #include "Attribute.h"                // for Attribute
+#include "Common/ToString.hpp"        // for toCString
 #include "Common/utility.h"           // for cloneAll, deleteAll, printAll
 #include "InitTweak/InitTweak.h"      // for getPointerBase
 …
 int Type::referenceDepth() const { return 0; }
+AggregateDecl * Type::getAggr() const {
+        assertf( false, "Non-aggregate type: %s", toCString( this ) );
+}
 TypeSubstitution Type::genericSubstitution() const { assertf( false, "Non-aggregate type: %s", toCString( this ) ); }

src/SynTree/Type.h

-              r34b4268
+              r24d6572
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Andrew Beach
 // Last Modified On : Wed Jul 14 15:40:00 2021
 // Update Count     : 171
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Sun Feb 19 22:37:10 2023
+// Update Count     : 176
 //
 …
 #include "BaseSyntaxNode.h"  // for BaseSyntaxNode
 #include "Common/utility.h"  // for operator+
+#include "Common/Iterate.hpp"// for operator+
 #include "Mutator.h"         // for Mutator
 #include "SynTree.h"         // for AST nodes
 …
                 bool operator!=( Qualifiers other ) const { return (val & Mask) != (other.val & Mask); }
                 bool operator<=( Qualifiers other ) const {
                         return is_const    <= other.is_const        //Any non-const converts to const without cost
                                         && is_volatile <= other.is_volatile     //Any non-volatile converts to volatile without cost
                                         && is_mutex    >= other.is_mutex        //Any mutex converts to non-mutex without cost
                                         && is_atomic   == other.is_atomic;      //No conversion from atomic to non atomic is free
+                        return is_const    <= other.is_const        // Any non-const converts to const without cost
+                                && is_volatile <= other.is_volatile             // Any non-volatile converts to volatile without cost
+                                && is_mutex    >= other.is_mutex                // Any mutex converts to non-mutex without cost
+                                && is_atomic   == other.is_atomic;              // No conversion from atomic to non atomic is free
+                }
                 bool operator<( Qualifiers other ) const { return *this != other && *this <= other; }
 …
         virtual bool isComplete() const { return true; }
         virtual AggregateDecl * getAggr() const { assertf( false, "Non-aggregate type: %s", toCString( this ) ); }
+        virtual AggregateDecl * getAggr() const;
         virtual TypeSubstitution genericSubstitution() const;
         virtual Type *clone() const = 0;
+        virtual Type * clone() const = 0;
         virtual void accept( Visitor & v ) = 0;
         virtual void accept( Visitor & v ) const = 0;
         virtual Type *acceptMutator( Mutator & m ) = 0;
+        virtual Type * acceptMutator( Mutator & m ) = 0;
         virtual void print( std::ostream & os, Indenter indent = {} ) const;
 };
 …
         virtual bool isComplete() const override { return false; }
         virtual VoidType *clone() const override { return new VoidType( *this ); }
         virtual void accept( Visitor & v ) override { v.visit( this ); }
         virtual void accept( Visitor & v ) const override { v.visit( this ); }
         virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual VoidType * clone() const override { return new VoidType( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
+        virtual Type * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };
 …
         // GENERATED END
         static const char *typeNames[];                                         // string names for basic types, MUST MATCH with Kind
+        static const char * typeNames[];                                        // string names for basic types, MUST MATCH with Kind
         BasicType( const Type::Qualifiers & tq, Kind bt, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
 …
         void set_kind( Kind newValue ) { kind = newValue; }
+        virtual BasicType *clone() const override { return new BasicType( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
+        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
+        bool isWholeNumber() const;
+        virtual BasicType * clone() const override { return new BasicType( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
+        virtual Type * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
         bool isInteger() const;
 };
 …
         // In C99, pointer types can be qualified in many ways e.g., int f( int a[ static 3 ] )
         Expression *dimension;
+        Expression * dimension;
         bool isVarLen;
         bool isStatic;
         PointerType( const Type::Qualifiers & tq, Type *base, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
         PointerType( const Type::Qualifiers & tq, Type *base, Expression *dimension, bool isVarLen, bool isStatic, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
+        PointerType( const Type::Qualifiers & tq, Type * base, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
+        PointerType( const Type::Qualifiers & tq, Type * base, Expression * dimension, bool isVarLen, bool isStatic, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
         PointerType( const PointerType& );
         virtual ~PointerType();
         Type *get_base() { return base; }
         void set_base( Type *newValue ) { base = newValue; }
         Expression *get_dimension() { return dimension; }
         void set_dimension( Expression *newValue ) { dimension = newValue; }
+        Type * get_base() { return base; }
+        void set_base( Type * newValue ) { base = newValue; }
+        Expression * get_dimension() { return dimension; }
+        void set_dimension( Expression * newValue ) { dimension = newValue; }
         bool get_isVarLen() { return isVarLen; }
         void set_isVarLen( bool newValue ) { isVarLen = newValue; }
 …
         virtual bool isComplete() const override { return ! isVarLen; }
         virtual PointerType *clone() const override { return new PointerType( *this ); }
         virtual void accept( Visitor & v ) override { v.visit( this ); }
         virtual void accept( Visitor & v ) const override { v.visit( this ); }
         virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual PointerType * clone() const override { return new PointerType( * this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
+        virtual Type * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };
 …
 class ArrayType : public Type {
   public:
         Type *base;
         Expression *dimension;
+        Type * base;
+        Expression * dimension;
         bool isVarLen;
         bool isStatic;
         ArrayType( const Type::Qualifiers & tq, Type *base, Expression *dimension, bool isVarLen, bool isStatic, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
+        ArrayType( const Type::Qualifiers & tq, Type * base, Expression * dimension, bool isVarLen, bool isStatic, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
         ArrayType( const ArrayType& );
         virtual ~ArrayType();
         Type *get_base() { return base; }
         void set_base( Type *newValue ) { base = newValue; }
         Expression *get_dimension() { return dimension; }
         void set_dimension( Expression *newValue ) { dimension = newValue; }
+        Type * get_base() { return base; }
+        void set_base( Type * newValue ) { base = newValue; }
+        Expression * get_dimension() { return dimension; }
+        void set_dimension( Expression * newValue ) { dimension = newValue; }
         bool get_isVarLen() { return isVarLen; }
         void set_isVarLen( bool newValue ) { isVarLen = newValue; }
 …
         virtual bool isComplete() const override { return dimension || isVarLen; }
         virtual ArrayType *clone() const override { return new ArrayType( *this ); }
         virtual void accept( Visitor & v ) override { v.visit( this ); }
         virtual void accept( Visitor & v ) const override { v.visit( this ); }
         virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual ArrayType * clone() const override { return new ArrayType( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
+        virtual Type * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };
 …
         virtual ~QualifiedType();
         virtual QualifiedType *clone() const override { return new QualifiedType( *this ); }
         virtual void accept( Visitor & v ) override { v.visit( this ); }
         virtual void accept( Visitor & v ) const override { v.visit( this ); }
         virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual QualifiedType * clone() const override { return new QualifiedType( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
+        virtual Type * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };
 …
 class ReferenceType : public Type {
 public:
         Type *base;
         ReferenceType( const Type::Qualifiers & tq, Type *base, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
+        Type * base;
+        ReferenceType( const Type::Qualifiers & tq, Type * base, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
         ReferenceType( const ReferenceType & );
         virtual ~ReferenceType();
         Type *get_base() { return base; }
         void set_base( Type *newValue ) { base = newValue; }
+        Type * get_base() { return base; }
+        void set_base( Type * newValue ) { base = newValue; }
         virtual int referenceDepth() const override;
 …
         virtual TypeSubstitution genericSubstitution() const override;
         virtual ReferenceType *clone() const override { return new ReferenceType( *this ); }
         virtual void accept( Visitor & v ) override { v.visit( this ); }
         virtual void accept( Visitor & v ) const override { v.visit( this ); }
         virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual ReferenceType * clone() const override { return new ReferenceType( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
+        virtual Type * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };
 …
         bool isUnprototyped() const { return isVarArgs && parameters.size() == 0; }
         virtual FunctionType *clone() const override { return new FunctionType( *this ); }
         virtual void accept( Visitor & v ) override { v.visit( this ); }
         virtual void accept( Visitor & v ) const override { v.visit( this ); }
         virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual FunctionType * clone() const override { return new FunctionType( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
+        virtual Type * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };
 …
 class ReferenceToType : public Type {
   public:
         std::list< Expression* > parameters;
+        std::list< Expression * > parameters;
         std::string name;
         bool hoistType;
 …
         void set_hoistType( bool newValue ) { hoistType = newValue; }
         virtual ReferenceToType *clone() const override = 0;
+        virtual ReferenceToType * clone() const override = 0;
         virtual void accept( Visitor & v ) override = 0;
         virtual Type *acceptMutator( Mutator & m ) override = 0;
+        virtual Type * acceptMutator( Mutator & m ) override = 0;
         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 …
         // this decl is not "owned" by the struct inst; it is merely a pointer to elsewhere in the tree,
         // where the structure used in this type is actually defined
         StructDecl *baseStruct;
+        StructDecl * baseStruct;
         StructInstType( const Type::Qualifiers & tq, const std::string & name, const std::list< Attribute * > & attributes = std::list< Attribute * >()  ) : Parent( tq, name, attributes ), baseStruct( 0 ) {}
 …
         StructInstType( const StructInstType & other ) : Parent( other ), baseStruct( other.baseStruct ) {}
         StructDecl *get_baseStruct() const { return baseStruct; }
         void set_baseStruct( StructDecl *newValue ) { baseStruct = newValue; }
+        StructDecl * get_baseStruct() const { return baseStruct; }
+        void set_baseStruct( StructDecl * newValue ) { baseStruct = newValue; }
         /// Accesses generic parameters of base struct (NULL if none such)
 …
         void lookup( const std::string & name, std::list< Declaration* > & foundDecls ) const override;
         virtual StructInstType *clone() const override { return new StructInstType( *this ); }
         virtual void accept( Visitor & v ) override { v.visit( this ); }
         virtual void accept( Visitor & v ) const override { v.visit( this ); }
         virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual StructInstType * clone() const override { return new StructInstType( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
+        virtual Type * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 …
         // this decl is not "owned" by the union inst; it is merely a pointer to elsewhere in the tree,
         // where the union used in this type is actually defined
         UnionDecl *baseUnion;
+        UnionDecl * baseUnion;
         UnionInstType( const Type::Qualifiers & tq, const std::string & name, const std::list< Attribute * > & attributes = std::list< Attribute * >()  ) : Parent( tq, name, attributes ), baseUnion( 0 ) {}
 …
         UnionInstType( const UnionInstType & other ) : Parent( other ), baseUnion( other.baseUnion ) {}
         UnionDecl *get_baseUnion() const { return baseUnion; }
+        UnionDecl * get_baseUnion() const { return baseUnion; }
         void set_baseUnion( UnionDecl * newValue ) { baseUnion = newValue; }
 …
         void lookup( const std::string & name, std::list< Declaration* > & foundDecls ) const override;
         virtual UnionInstType *clone() const override { return new UnionInstType( *this ); }
         virtual void accept( Visitor & v ) override { v.visit( this ); }
         virtual void accept( Visitor & v ) const override { v.visit( this ); }
         virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual UnionInstType * clone() const override { return new UnionInstType( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
+        virtual Type * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 …
         // this decl is not "owned" by the enum inst; it is merely a pointer to elsewhere in the tree,
         // where the enum used in this type is actually defined
         EnumDecl *baseEnum = nullptr;
+        EnumDecl * baseEnum = nullptr;
         EnumInstType( const Type::Qualifiers & tq, const std::string & name, const std::list< Attribute * > & attributes = std::list< Attribute * >()  ) : Parent( tq, name, attributes ) {}
 …
         EnumInstType( const EnumInstType & other ) : Parent( other ), baseEnum( other.baseEnum ) {}
         EnumDecl *get_baseEnum() const { return baseEnum; }
         void set_baseEnum( EnumDecl *newValue ) { baseEnum = newValue; }
+        EnumDecl * get_baseEnum() const { return baseEnum; }
+        void set_baseEnum( EnumDecl * newValue ) { baseEnum = newValue; }
         virtual bool isComplete() const override;
 …
         virtual AggregateDecl * getAggr() const override;
         virtual EnumInstType *clone() const override { return new EnumInstType( *this ); }
         virtual void accept( Visitor & v ) override { v.visit( this ); }
         virtual void accept( Visitor & v ) const override { v.visit( this ); }
         virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual EnumInstType * clone() const override { return new EnumInstType( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
+        virtual Type * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 …
         virtual bool isComplete() const override;
         virtual TraitInstType *clone() const override { return new TraitInstType( *this ); }
         virtual void accept( Visitor & v ) override { v.visit( this ); }
         virtual void accept( Visitor & v ) const override { v.visit( this ); }
         virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual TraitInstType * clone() const override { return new TraitInstType( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
+        virtual Type * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
   private:
         virtual std::string typeString() const override;
 …
         // this decl is not "owned" by the type inst; it is merely a pointer to elsewhere in the tree,
         // where the type used here is actually defined
         TypeDecl *baseType;
+        TypeDecl * baseType;
         bool isFtype;
         TypeInstType( const Type::Qualifiers & tq, const std::string & name, TypeDecl *baseType, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
+        TypeInstType( const Type::Qualifiers & tq, const std::string & name, TypeDecl * baseType, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
         TypeInstType( const Type::Qualifiers & tq, const std::string & name, bool isFtype, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
         TypeInstType( const TypeInstType & other );
         ~TypeInstType();
         TypeDecl *get_baseType() const { return baseType; }
         void set_baseType( TypeDecl *newValue );
+        TypeDecl * get_baseType() const { return baseType; }
+        void set_baseType( TypeDecl * newValue );
         bool get_isFtype() const { return isFtype; }
         void set_isFtype( bool newValue ) { isFtype = newValue; }
 …
         virtual bool isComplete() const override;
         virtual TypeInstType *clone() const override { return new TypeInstType( *this ); }
         virtual void accept( Visitor & v ) override { v.visit( this ); }
         virtual void accept( Visitor & v ) const override { v.visit( this ); }
         virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual TypeInstType * clone() const override { return new TypeInstType( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
+        virtual Type * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
   private:
 …
         // virtual bool isComplete() const override { return true; } // xxx - not sure if this is right, might need to recursively check complete-ness
         virtual TupleType *clone() const override { return new TupleType( *this ); }
         virtual void accept( Visitor & v ) override { v.visit( this ); }
         virtual void accept( Visitor & v ) const override { v.visit( this ); }
         virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual TupleType * clone() const override { return new TupleType( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
+        virtual Type * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };
 …
 class TypeofType : public Type {
   public:
         Expression *expr;    ///< expression to take the type of
         bool is_basetypeof;  ///< true iff is basetypeof type
         TypeofType( const Type::Qualifiers & tq, Expression *expr, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
         TypeofType( const Type::Qualifiers & tq, Expression *expr, bool is_basetypeof,
+        Expression * expr;              ///< expression to take the type of
+        bool is_basetypeof;             ///< true iff is basetypeof type
+        TypeofType( const Type::Qualifiers & tq, Expression * expr, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
+        TypeofType( const Type::Qualifiers & tq, Expression * expr, bool is_basetypeof,
                 const std::list< Attribute * > & attributes = std::list< Attribute * >() );
         TypeofType( const TypeofType& );
         virtual ~TypeofType();
         Expression *get_expr() const { return expr; }
         void set_expr( Expression *newValue ) { expr = newValue; }
+        Expression * get_expr() const { return expr; }
+        void set_expr( Expression * newValue ) { expr = newValue; }
         virtual bool isComplete() const override { assert( false ); return false; }
         virtual TypeofType *clone() const override { return new TypeofType( *this ); }
         virtual void accept( Visitor & v ) override { v.visit( this ); }
         virtual void accept( Visitor & v ) const override { v.visit( this ); }
         virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual TypeofType * clone() const override { return new TypeofType( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
+        virtual Type * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };
 …
 class VTableType : public Type {
 public:
         Type *base;
         VTableType( const Type::Qualifiers & tq, Type *base,
+        Type * base;
+        VTableType( const Type::Qualifiers & tq, Type * base,
                 const std::list< Attribute * > & attributes = std::list< Attribute * >() );
         VTableType( const VTableType & );
         virtual ~VTableType();
         Type *get_base() { return base; }
         void set_base( Type *newValue ) { base = newValue; }
         virtual VTableType *clone() const override { return new VTableType( *this ); }
         virtual void accept( Visitor & v ) override { v.visit( this ); }
         virtual void accept( Visitor & v ) const override { v.visit( this ); }
         virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        Type * get_base() { return base; }
+        void set_base( Type * newValue ) { base = newValue; }
+        virtual VTableType * clone() const override { return new VTableType( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
+        virtual Type * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };
 …
   public:
         std::string name;
         Expression *expr;
         Type *type;
+        Expression * expr;
+        Type * type;
         bool isType;
         AttrType( const Type::Qualifiers & tq, const std::string & name, Expression *expr, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
         AttrType( const Type::Qualifiers & tq, const std::string & name, Type *type, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
+        AttrType( const Type::Qualifiers & tq, const std::string & name, Expression * expr, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
+        AttrType( const Type::Qualifiers & tq, const std::string & name, Type * type, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
         AttrType( const AttrType& );
         virtual ~AttrType();
 …
         const std::string & get_name() const { return name; }
         void set_name( const std::string & newValue ) { name = newValue; }
         Expression *get_expr() const { return expr; }
         void set_expr( Expression *newValue ) { expr = newValue; }
         Type *get_type() const { return type; }
         void set_type( Type *newValue ) { type = newValue; }
+        Expression * get_expr() const { return expr; }
+        void set_expr( Expression * newValue ) { expr = newValue; }
+        Type * get_type() const { return type; }
+        void set_type( Type * newValue ) { type = newValue; }
         bool get_isType() const { return isType; }
         void set_isType( bool newValue ) { isType = newValue; }
 …
         virtual bool isComplete() const override { assert( false ); } // xxx - not sure what to do here
         virtual AttrType *clone() const override { return new AttrType( *this ); }
         virtual void accept( Visitor & v ) override { v.visit( this ); }
         virtual void accept( Visitor & v ) const override { v.visit( this ); }
         virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual AttrType * clone() const override { return new AttrType( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
+        virtual Type * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };
 …
         virtual bool isComplete() const override{ return true; } // xxx - is this right?
         virtual VarArgsType *clone() const override { return new VarArgsType( *this ); }
         virtual void accept( Visitor & v ) override { v.visit( this ); }
         virtual void accept( Visitor & v ) const override { v.visit( this ); }
         virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual VarArgsType * clone() const override { return new VarArgsType( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
+        virtual Type * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };
 …
         ZeroType( Type::Qualifiers tq, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
         virtual ZeroType *clone() const override { return new ZeroType( *this ); }
         virtual void accept( Visitor & v ) override { v.visit( this ); }
         virtual void accept( Visitor & v ) const override { v.visit( this ); }
         virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual ZeroType * clone() const override { return new ZeroType( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
+        virtual Type * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };
 …
         OneType( Type::Qualifiers tq, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
         virtual OneType *clone() const override { return new OneType( *this ); }
         virtual void accept( Visitor & v ) override { v.visit( this ); }
         virtual void accept( Visitor & v ) const override { v.visit( this ); }
         virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual OneType * clone() const override { return new OneType( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
+        virtual Type * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };
 …
         GlobalScopeType();
         virtual GlobalScopeType *clone() const override { return new GlobalScopeType( *this ); }
         virtual void accept( Visitor & v ) override { v.visit( this ); }
         virtual void accept( Visitor & v ) const override { v.visit( this ); }
         virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual GlobalScopeType * clone() const override { return new GlobalScopeType( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
+        virtual Type * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };

src/Tuples/Explode.cc

r34b4268	r24d6572
17	17	#include <list> // for list
18	18
	19	#include "AST/Pass.hpp" // for Pass
19	20	#include "SynTree/Mutator.h" // for Mutator
20	21	#include "Common/PassVisitor.h" // for PassVisitor

src/Validate/Autogen.cpp

-              r34b4268
+              r24d6572
 #include "AST/Attribute.hpp"
+#include "AST/Copy.hpp"
 #include "AST/Create.hpp"
 #include "AST/Decl.hpp"
 …
 #include "InitTweak/GenInit.h"     // for fixReturnStatements
 #include "InitTweak/InitTweak.h"   // for isAssignment, isCopyConstructor
+#include "SymTab/GenImplicitCall.hpp"  // for genImplicitCall
 #include "SymTab/Mangler.h"        // for Mangler
 #include "CompilationState.h"
-// TODO: The other new ast function should be moved over to this file.
-#include "SymTab/Autogen.h"
 namespace Validate {
 …
         const CodeLocation& getLocation() const { return getDecl()->location; }
         ast::FunctionDecl * genProto( const std::string& name,
+        ast::FunctionDecl * genProto( std::string&& name,
                 std::vector<ast::ptr<ast::DeclWithType>>&& params,
                 std::vector<ast::ptr<ast::DeclWithType>>&& returns ) const;
 …
 void FuncGenerator::produceDecl( const ast::FunctionDecl * decl ) {
         assert( nullptr != decl->stmts );
+        const auto & oldParams = getGenericParams(type);
+        assert( decl->type_params.size() == oldParams.size());
+        /*
+        ast::DeclReplacer::TypeMap typeMap;
+        for (auto it = oldParams.begin(), jt = decl->type_params.begin(); it != oldParams.end(); ++it, ++jt) {
+                typeMap.emplace(*it, *jt);
+        }
+        const ast::FunctionDecl * mut = strict_dynamic_cast<const ast::FunctionDecl *>(ast::DeclReplacer::replace(decl, typeMap));
+        assert (mut == decl);
+        */
         definitions.push_back( decl );
 …
+}
+void replaceAll( std::vector<ast::ptr<ast::DeclWithType>> & dwts,
+                const ast::DeclReplacer::TypeMap & map ) {
+        for ( auto & dwt : dwts ) {
+                dwt = strict_dynamic_cast<const ast::DeclWithType *>(
+                                ast::DeclReplacer::replace( dwt, map ) );
+        }
+}
 /// Generates a basic prototype function declaration.
 ast::FunctionDecl * FuncGenerator::genProto( const std::string& name,
+ast::FunctionDecl * FuncGenerator::genProto( std::string&& name,
                 std::vector<ast::ptr<ast::DeclWithType>>&& params,
                 std::vector<ast::ptr<ast::DeclWithType>>&& returns ) const {
 …
         // Handle generic prameters and assertions, if any.
         auto const & old_type_params = getGenericParams( type );
+        ast::DeclReplacer::TypeMap oldToNew;
         std::vector<ast::ptr<ast::TypeDecl>> type_params;
         std::vector<ast::ptr<ast::DeclWithType>> assertions;
+        ast::DeclReplacer::TypeMap typeMap;
         for ( auto & old_param : old_type_params ) {
                 ast::TypeDecl * decl = ast::deepCopy( old_param );
+                for ( auto assertion : decl->assertions ) {
+                        assertions.push_back( assertion );
+                }
+                decl->assertions.clear();
+                decl->init = nullptr;
+                splice( assertions, decl->assertions );
+                oldToNew.emplace( std::make_pair( old_param, decl ) );
                 type_params.push_back( decl );
+        }
+        // TODO: The values in params and returns still may point at the old
+        // generic params, that does not appear to be an issue but perhaps it
+        // should be addressed.
+                typeMap.emplace(old_param, decl);
+        }
+        for (auto & param : params) {
+                param = ast::DeclReplacer::replace(param, typeMap);
+        }
+        for (auto & param : returns) {
+                param = ast::DeclReplacer::replace(param, typeMap);
+        }
+        replaceAll( params, oldToNew );
+        replaceAll( returns, oldToNew );
+        replaceAll( assertions, oldToNew );
         ast::FunctionDecl * decl = new ast::FunctionDecl(
                 // Auto-generated routines use the type declaration's location.
                 getLocation(),
                 name,
+                std::move( name ),
                 std::move( type_params ),
                 std::move( assertions ),
 …
         for ( unsigned int index = 0 ; index < fields ; ++index ) {
                 auto member = aggr->members[index].strict_as<ast::DeclWithType>();
                 if ( SymTab::isUnnamedBitfield(
+                if ( ast::isUnnamedBitfield(
                                 dynamic_cast<const ast::ObjectDecl *>( member ) ) ) {
                         if ( index == fields - 1 ) {
 …
         InitTweak::InitExpander_new srcParam( src );
         // Assign to destination.
         ast::Expr * dstSelect = new ast::MemberExpr(
+        ast::MemberExpr * dstSelect = new ast::MemberExpr(
                 location,
                 field,
 …
+                }
                 ast::Expr * srcSelect = (srcParam) ? new ast::MemberExpr(
+                ast::MemberExpr * srcSelect = (srcParam) ? new ast::MemberExpr(
                         location, field, new ast::VariableExpr( location, srcParam )
                 ) : nullptr;
 …
                 // Not sure why it could be null.
                 // Don't make a function for a parameter that is an unnamed bitfield.
                 if ( nullptr == field || SymTab::isUnnamedBitfield( field ) ) {
+                if ( nullptr == field || ast::isUnnamedBitfield( field ) ) {
                         continue;
                 // Matching Parameter: Initialize the field by copy.

src/Validate/FixQualifiedTypes.cpp

-              r34b4268
+              r24d6572
 #include "Validate/FixQualifiedTypes.hpp"
+#include "AST/Copy.hpp"
+#include "AST/LinkageSpec.hpp"             // for Linkage
 #include "AST/Pass.hpp"
 #include "AST/TranslationUnit.hpp"
+#include "Common/ToString.hpp"             // for toString
+#include "SymTab/Mangler.h"                // for Mangler
 #include "Validate/NoIdSymbolTable.hpp"
-#include "SymTab/Mangler.h"            // for Mangler
-#include "AST/LinkageSpec.hpp"                     // for Linkage
 namespace Validate {

src/Validate/FixReturnTypes.cpp

r34b4268	r24d6572
20	20	#include "AST/Type.hpp"
21	21	#include "CodeGen/CodeGenerator.h"
22		#include "ResolvExpr/~~typeops~~.h"
	22	#include "ResolvExpr/Unify.h"
23	23
24	24	namespace ast {

src/Validate/ForallPointerDecay.cpp

r34b4268	r24d6572
22	22	#include "CodeGen/OperatorTable.h"
23	23	#include "Common/CodeLocation.h"
	24	#include "Common/ToString.hpp"
24	25	#include "SymTab/FixFunction.h"
25	26

src/Validate/GenericParameter.cpp

r34b4268	r24d6572
16	16	#include "GenericParameter.hpp"
17	17
	18	#include "AST/Copy.hpp"
18	19	#include "AST/Decl.hpp"
19	20	#include "AST/Expr.hpp"

src/Validate/HandleAttributes.cc

-              r34b4268
+              r24d6572
 #include "CompilationState.h"
+#include "Common/Eval.h"
 #include "Common/PassVisitor.h"
+#include "Common/ToString.hpp"
 #include "Common/SemanticError.h"
 #include "ResolvExpr/Resolver.h"

src/Validate/HoistStruct.cpp

-              r34b4268
+              r24d6572
 #include "Validate/HoistStruct.hpp"
+#include <sstream>
 #include "AST/Pass.hpp"
 #include "AST/TranslationUnit.hpp"
-#include "Common/utility.h"
 namespace Validate {

src/Validate/ReplaceTypedef.cpp

-              r34b4268
+              r24d6572
 #include "ReplaceTypedef.hpp"
+#include "AST/Copy.hpp"
 #include "AST/Pass.hpp"
 #include "Common/ScopedMap.h"
 #include "Common/UniqueName.h"
 #include "Common/utility.h"
 #include "ResolvExpr/typeops.h"
+#include "ResolvExpr/Unify.h"
 namespace Validate {
 …
                 // constant/enumerator. The effort required to fix this corner case
                 // likely outweighs the utility of allowing it.
                 if ( !ResolvExpr::typesCompatible( t0, t1, ast::SymbolTable() )
+                if ( !ResolvExpr::typesCompatible( t0, t1 )
                                 || ast::Pass<VarLenChecker>::read( t0 )
                                 || ast::Pass<VarLenChecker>::read( t1 ) ) {
 …
 void ReplaceTypedefCore::previsit( ast::TypeDecl const * decl ) {
+        TypedefMap::iterator iter = typedefNames.find( decl->name );
+        if ( iter != typedefNames.end() ) {
+                typedefNames.erase( iter );
+        }
+        typedefNames.erase( decl->name );
         typedeclNames.insert( decl->name, decl );
+}

src/Virtual/ExpandCasts.cc

r34b4268	r24d6572
20	20	#include <string> // for string, allocator, operator==, ope...
21	21
	22	#include "AST/Copy.hpp"
22	23	#include "AST/Decl.hpp"
23	24	#include "AST/Expr.hpp"

src/Virtual/module.mk

r34b4268	r24d6572
19	19	Virtual/ExpandCasts.h \
20	20	Virtual/Tables.cc \
21		Virtual/Tables.h
	21	Virtual/Tables.h \
	22	Virtual/VirtualDtor.cpp \
	23	Virtual/VirtualDtor.hpp

src/include/cassert

-              r34b4268
+              r24d6572
 #include_next <cassert>
+#include <string>
+template < typename ... Params >
+std::string toString( const Params & ... params );
+#include "Common/ToString.hpp"
 #ifdef NDEBUG

src/main.cc

-              r34b4268
+              r24d6572
 // Author           : Peter Buhr and Rob Schluntz
 // Created On       : Fri May 15 23:12:02 2015
 // Last Modified By : Andrew Beach
 // Last Modified On : Wed Oct  5 12:06:00 2022
 // Update Count     : 679
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Mon Apr 10 21:12:17 2023
+// Update Count     : 682
 //
 …
 #include "AST/Convert.hpp"
+#include "AST/Pass.hpp"                     // for pass_visitor_stats
+#include "AST/TranslationUnit.hpp"          // for TranslationUnit
+#include "AST/Util.hpp"                     // for checkInvariants
 #include "CompilationState.h"
 #include "../config.h"                      // for CFA_LIBDIR
 …
 #include "CodeTools/TrackLoc.h"             // for fillLocations
 #include "Common/CodeLocationTools.hpp"     // for forceFillCodeLocations
-#include "Common/CompilerError.h"           // for CompilerError
 #include "Common/DeclStats.hpp"             // for printDeclStats
 #include "Common/ResolvProtoDump.hpp"       // for dumpAsResolverProto
 #include "Common/Stats.h"                   // for Stats
-#include "Common/UnimplementedError.h"      // for UnimplementedError
 #include "Common/utility.h"                 // for deleteAll, filter, printAll
+#include "Concurrency/Actors.hpp"           // for implementActors
 #include "Concurrency/Keywords.h"           // for implementMutex, implement...
 #include "Concurrency/Waitfor.h"            // for generateWaitfor
+#include "Concurrency/Waituntil.hpp"        // for generateWaitUntil
 #include "ControlStruct/ExceptDecl.h"       // for translateExcept
 #include "ControlStruct/ExceptTranslate.h"  // for translateThrows, translat...
 …
 #include "InitTweak/GenInit.h"              // for genInit
 #include "MakeLibCfa.h"                     // for makeLibCfa
+#include "Parser/ParseNode.h"               // for DeclarationNode, buildList
+#include "Parser/TypedefTable.h"            // for TypedefTable
+#include "Parser/RunParser.hpp"             // for buildList, dumpParseTree,...
 #include "ResolvExpr/CandidatePrinter.hpp"  // for printCandidates
 #include "ResolvExpr/Resolver.h"            // for resolve
 …
 #include "Validate/VerifyCtorDtorAssign.hpp" // for verifyCtorDtorAssign
 #include "Virtual/ExpandCasts.h"            // for expandCasts
+#include "Virtual/VirtualDtor.hpp"           // for implementVirtDtors
 static void NewPass( const char * const name ) {
 …
+}
+#define PASS( name, pass )                  \
+// Helpers for checkInvariant:
+void checkInvariants( std::list< Declaration * > & ) {}
+using ast::checkInvariants;
+#define PASS( name, pass, unit, ... )       \
         if ( errorp ) { cerr << name << endl; } \
         NewPass(name);                          \
         Stats::Time::StartBlock(name);          \
+        pass;                                   \
+        Stats::Time::StopBlock();
+LinkageSpec::Spec linkage = LinkageSpec::Cforall;
+TypedefTable typedefTable;
+DeclarationNode * parseTree = nullptr;                                  // program parse tree
+        pass(unit,##__VA_ARGS__);               \
+        Stats::Time::StopBlock();               \
+        if ( invariant ) {                      \
+                checkInvariants(unit);              \
+        }
+#define DUMP( cond, unit )                  \
+        if ( cond ) {                           \
+                dump(unit);                         \
+                return EXIT_SUCCESS;                \
+        }
 static bool waiting_for_gdb = false;                                    // flag to set cfa-cpp to wait for gdb on start
 …
 static void parse_cmdline( int argc, char * argv[] );
-static void parse( FILE * input, LinkageSpec::Spec linkage, bool shouldExit = false );
 static void dump( list< Declaration * > & translationUnit, ostream & out = cout );
 static void dump( ast::TranslationUnit && transUnit, ostream & out = cout );
 …
         ostream * output = & cout;
         list< Declaration * > translationUnit;
+        ast::TranslationUnit transUnit;
         Signal( SIGSEGV, sigSegvBusHandler, SA_SIGINFO );
 …
                         FILE * gcc_builtins = fopen( (PreludeDirector + "/gcc-builtins.cf").c_str(), "r" );
                         assertf( gcc_builtins, "cannot open gcc-builtins.cf\n" );
                         parse( gcc_builtins, LinkageSpec::Compiler );
+                        parse( gcc_builtins, ast::Linkage::Compiler );
                         // read the extra prelude in, if not generating the cfa library
                         FILE * extras = fopen( (PreludeDirector + "/extras.cf").c_str(), "r" );
                         assertf( extras, "cannot open extras.cf\n" );
                         parse( extras, LinkageSpec::BuiltinC );
+                        parse( extras, ast::Linkage::BuiltinC );
                         if ( ! libcfap ) {
 …
                                 FILE * prelude = fopen( (PreludeDirector + "/prelude.cfa").c_str(), "r" );
                                 assertf( prelude, "cannot open prelude.cfa\n" );
                                 parse( prelude, LinkageSpec::Intrinsic );
+                                parse( prelude, ast::Linkage::Intrinsic );
                                 // Read to cfa builtins, if not generating the cfa library
                                 FILE * builtins = fopen( (PreludeDirector + "/builtins.cf").c_str(), "r" );
                                 assertf( builtins, "cannot open builtins.cf\n" );
+                                parse( builtins, LinkageSpec::BuiltinCFA );
+                        } // if
+                } // if
+                parse( input, libcfap ? LinkageSpec::Intrinsic : LinkageSpec::Cforall, yydebug );
+                if ( parsep ) {
+                        parseTree->printList( cout );
+                        delete parseTree;
+                        return EXIT_SUCCESS;
+                } // if
+                buildList( parseTree, translationUnit );
+                delete parseTree;
+                parseTree = nullptr;
+                if ( astp ) {
+                        dump( translationUnit );
+                        return EXIT_SUCCESS;
+                } // if
+                // Temporary: fill locations after parsing so that every node has a location, for early error messages.
+                // Eventually we should pass the locations from the parser to every node, but this quick and dirty solution
+                // works okay for now.
+                CodeTools::fillLocations( translationUnit );
+                                parse( builtins, ast::Linkage::BuiltinCFA );
+                        } // if
+                } // if
+                parse( input, libcfap ? ast::Linkage::Intrinsic : ast::Linkage::Cforall, yydebug );
+                transUnit = buildUnit();
+                DUMP( astp, std::move( transUnit ) );
                 Stats::Time::StopBlock();
 …
                         ast::pass_visitor_stats.max = Stats::Counters::build<Stats::Counters::MaxCounter<double>>("Max depth - New");
+                }
+                auto transUnit = convert( std::move( translationUnit ) );
+                forceFillCodeLocations( transUnit );
+                PASS( "Translate Exception Declarations", ControlStruct::translateExcept( transUnit ) );
+                if ( exdeclp ) {
+                        dump( std::move( transUnit ) );
+                        return EXIT_SUCCESS;
+                }
+                PASS( "Verify Ctor, Dtor & Assign", Validate::verifyCtorDtorAssign( transUnit ) );
+                PASS( "Hoist Type Decls", Validate::hoistTypeDecls( transUnit ) );
+                // Hoist Type Decls pulls some declarations out of contexts where
+                // locations are not tracked. Perhaps they should be, but for now
+                // the full fill solves it.
+                forceFillCodeLocations( transUnit );
+                PASS( "Replace Typedefs", Validate::replaceTypedef( transUnit ) );
+                PASS( "Fix Return Types", Validate::fixReturnTypes( transUnit ) );
+                PASS( "Enum and Pointer Decay", Validate::decayEnumsAndPointers( transUnit ) );
+                PASS( "Link Reference To Types", Validate::linkReferenceToTypes( transUnit ) );
+                PASS( "Fix Qualified Types", Validate::fixQualifiedTypes( transUnit ) );
+                PASS( "Hoist Struct", Validate::hoistStruct( transUnit ) );
+                PASS( "Eliminate Typedef", Validate::eliminateTypedef( transUnit ) );
+                PASS( "Validate Generic Parameters", Validate::fillGenericParameters( transUnit ) );
+                PASS( "Translate Dimensions", Validate::translateDimensionParameters( transUnit ) );
+                PASS( "Check Function Returns", Validate::checkReturnStatements( transUnit ) );
+                PASS( "Fix Return Statements", InitTweak::fixReturnStatements( transUnit ) );
+                PASS( "Implement Concurrent Keywords", Concurrency::implementKeywords( transUnit ) );
+                PASS( "Forall Pointer Decay", Validate::decayForallPointers( transUnit ) );
+                PASS( "Hoist Control Declarations", ControlStruct::hoistControlDecls( transUnit ) );
+                PASS( "Generate Autogen Routines", Validate::autogenerateRoutines( transUnit ) );
+                PASS( "Implement Mutex", Concurrency::implementMutex( transUnit ) );
+                PASS( "Implement Thread Start", Concurrency::implementThreadStarter( transUnit ) );
+                PASS( "Compound Literal", Validate::handleCompoundLiterals( transUnit ) );
+                PASS( "Set Length From Initializer", Validate::setLengthFromInitializer( transUnit ) );
+                PASS( "Find Global Decls", Validate::findGlobalDecls( transUnit ) );
+                PASS( "Fix Label Address", Validate::fixLabelAddresses( transUnit ) );
+                PASS( "Hoist Type Decls", Validate::hoistTypeDecls, transUnit );
+                PASS( "Translate Exception Declarations", ControlStruct::translateExcept, transUnit );
+                DUMP( exdeclp, std::move( transUnit ) );
+                PASS( "Verify Ctor, Dtor & Assign", Validate::verifyCtorDtorAssign, transUnit );
+                PASS( "Replace Typedefs", Validate::replaceTypedef, transUnit );
+                PASS( "Fix Return Types", Validate::fixReturnTypes, transUnit );
+                PASS( "Enum and Pointer Decay", Validate::decayEnumsAndPointers, transUnit );
+                PASS( "Link Reference To Types", Validate::linkReferenceToTypes, transUnit );
+                PASS( "Fix Qualified Types", Validate::fixQualifiedTypes, transUnit );
+                PASS( "Hoist Struct", Validate::hoistStruct, transUnit );
+                PASS( "Eliminate Typedef", Validate::eliminateTypedef, transUnit );
+                PASS( "Validate Generic Parameters", Validate::fillGenericParameters, transUnit );
+                PASS( "Translate Dimensions", Validate::translateDimensionParameters, transUnit );
+                PASS( "Check Function Returns", Validate::checkReturnStatements, transUnit );
+                PASS( "Fix Return Statements", InitTweak::fixReturnStatements, transUnit );
+                PASS( "Implement Concurrent Keywords", Concurrency::implementKeywords, transUnit );
+                PASS( "Forall Pointer Decay", Validate::decayForallPointers, transUnit );
+        PASS( "Implement Waituntil", Concurrency::generateWaitUntil, transUnit  );
+                PASS( "Hoist Control Declarations", ControlStruct::hoistControlDecls, transUnit );
+                PASS( "Generate Autogen Routines", Validate::autogenerateRoutines, transUnit );
+                PASS( "Implement Actors", Concurrency::implementActors, transUnit );
+                PASS( "Implement Virtual Destructors", Virtual::implementVirtDtors, transUnit );
+                PASS( "Implement Mutex", Concurrency::implementMutex, transUnit );
+                PASS( "Implement Thread Start", Concurrency::implementThreadStarter, transUnit );
+                PASS( "Compound Literal", Validate::handleCompoundLiterals, transUnit );
+                PASS( "Set Length From Initializer", Validate::setLengthFromInitializer, transUnit );
+                PASS( "Find Global Decls", Validate::findGlobalDecls, transUnit );
+                PASS( "Fix Label Address", Validate::fixLabelAddresses, transUnit );
                 if ( symtabp ) {
 …
                 } // if
+                if ( validp ) {
+                        dump( std::move( transUnit ) );
+                        return EXIT_SUCCESS;
+                } // if
+                PASS( "Translate Throws", ControlStruct::translateThrows( transUnit ) );
+                PASS( "Fix Labels", ControlStruct::fixLabels( transUnit ) );
+                PASS( "Fix Names", CodeGen::fixNames( transUnit ) );
+                PASS( "Gen Init", InitTweak::genInit( transUnit ) );
+                PASS( "Expand Member Tuples" , Tuples::expandMemberTuples( transUnit ) );
+                DUMP( validp, std::move( transUnit ) );
+                PASS( "Translate Throws", ControlStruct::translateThrows, transUnit );
+                PASS( "Fix Labels", ControlStruct::fixLabels, transUnit );
+                PASS( "Fix Names", CodeGen::fixNames, transUnit );
+                PASS( "Gen Init", InitTweak::genInit, transUnit );
+                PASS( "Expand Member Tuples" , Tuples::expandMemberTuples, transUnit );
                 if ( libcfap ) {
 …
                 } // if
+                if ( bresolvep ) {
+                        dump( std::move( transUnit ) );
+                        return EXIT_SUCCESS;
+                } // if
+                DUMP( bresolvep, std::move( transUnit ) );
                 if ( resolvprotop ) {
 …
                 } // if
+                PASS( "Resolve", ResolvExpr::resolve( transUnit ) );
+                if ( exprp ) {
+                        dump( std::move( transUnit ) );
+                        return EXIT_SUCCESS;
+                } // if
+                forceFillCodeLocations( transUnit );
+                PASS( "Fix Init", InitTweak::fix(transUnit, buildingLibrary()));
+                PASS( "Resolve", ResolvExpr::resolve, transUnit );
+                DUMP( exprp, std::move( transUnit ) );
+                PASS( "Fix Init", InitTweak::fix, transUnit, buildingLibrary() );
                 // fix ObjectDecl - replaces ConstructorInit nodes
+                if ( ctorinitp ) {
+                        dump( std::move( transUnit ) );
+                        return EXIT_SUCCESS;
+                } // if
+                DUMP( ctorinitp, std::move( transUnit ) );
                 // Currently not working due to unresolved issues with UniqueExpr
                 PASS( "Expand Unique Expr", Tuples::expandUniqueExpr( transUnit ) ); // 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 Tries", ControlStruct::translateTries( transUnit ) );
                 PASS( "Gen Waitfor", Concurrency::generateWaitFor( transUnit ) );
+                PASS( "Expand Unique Expr", Tuples::expandUniqueExpr, transUnit ); // 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 Tries", ControlStruct::translateTries, transUnit );
+                PASS( "Gen Waitfor", Concurrency::generateWaitFor, transUnit );
                 // Needs to happen before tuple types are expanded.
+                PASS( "Convert Specializations",  GenPoly::convertSpecializations( transUnit ) );
+                PASS( "Expand Tuples", Tuples::expandTuples( transUnit ) );
+                if ( tuplep ) {
+                        dump( std::move( transUnit ) );
+                        return EXIT_SUCCESS;
+                } // if
+                PASS( "Convert Specializations",  GenPoly::convertSpecializations, transUnit );
+                PASS( "Expand Tuples", Tuples::expandTuples, transUnit );
+                DUMP( tuplep, std::move( transUnit ) );
                 // Must come after Translate Tries.
+                PASS( "Virtual Expand Casts", Virtual::expandCasts( transUnit ) );
+                PASS( "Instantiate Generics", GenPoly::instantiateGeneric( transUnit ) );
+                if ( genericsp ) {
+                        dump( std::move( transUnit ) );
+                        return EXIT_SUCCESS;
+                } // if
+                PASS( "Convert L-Value", GenPoly::convertLvalue( transUnit ) );
+                PASS( "Virtual Expand Casts", Virtual::expandCasts, transUnit );
+                PASS( "Instantiate Generics", GenPoly::instantiateGeneric, transUnit );
+                DUMP( genericsp, std::move( transUnit ) );
+                PASS( "Convert L-Value", GenPoly::convertLvalue, transUnit );
                 translationUnit = convert( std::move( transUnit ) );
+                if ( bboxp ) {
+                        dump( translationUnit );
+                        return EXIT_SUCCESS;
+                } // if
+                PASS( "Box", GenPoly::box( translationUnit ) );
+                PASS( "Link-Once", CodeGen::translateLinkOnce( translationUnit ) );
+                DUMP( bboxp, translationUnit );
+                PASS( "Box", GenPoly::box, translationUnit );
+                PASS( "Link-Once", CodeGen::translateLinkOnce, translationUnit );
                 // Code has been lowered to C, now we can start generation.
+                if ( bcodegenp ) {
+                        dump( translationUnit );
+                        return EXIT_SUCCESS;
+                } // if
+                DUMP( bcodegenp, translationUnit );
                 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( "Code Gen", CodeGen::generate, translationUnit, *output, ! genproto, prettycodegenp, true, linemarks );
                 CodeGen::FixMain::fix( translationUnit, *output,
 …
                 if ( errorp ) {
                         cerr << "---AST at error:---" << endl;
+                        dump( translationUnit, cerr );
+                        // We check which section the errors came from without looking at
+                        // transUnit because std::move means it could look like anything.
+                        if ( !translationUnit.empty() ) {
+                                dump( translationUnit, cerr );
+                        } else {
+                                dump( std::move( transUnit ), cerr );
+                        }
                         cerr << endl << "---End of AST, begin error message:---\n" << endl;
                 } // if
                 e.print();
-                if ( output != &cout ) {
-                        delete output;
-                } // if
-                return EXIT_FAILURE;
-        } catch ( UnimplementedError & e ) {
-                cout << "Sorry, " << e.get_what() << " is not currently implemented" << endl;
-                if ( output != &cout ) {
-                        delete output;
-                } // if
-                return EXIT_FAILURE;
-        } catch ( CompilerError & e ) {
-                cerr << "Compiler Error: " << e.get_what() << endl;
-                cerr << "(please report bugs to [REDACTED])" << endl;
                 if ( output != &cout ) {
                         delete output;
 …
 static const char optstring[] = ":c:ghlLmNnpdP:S:twW:D:";
+static const char optstring[] = ":c:ghilLmNnpdP:S:twW:D:";
 enum { PreludeDir = 128 };
 …
         { "gdb", no_argument, nullptr, 'g' },
         { "help", no_argument, nullptr, 'h' },
+        { "invariant", no_argument, nullptr, 'i' },
         { "libcfa", no_argument, nullptr, 'l' },
         { "linemarks", no_argument, nullptr, 'L' },
         { "no-main", no_argument, 0, 'm' },
+        { "no-main", no_argument, nullptr, 'm' },
         { "no-linemarks", no_argument, nullptr, 'N' },
         { "no-prelude", no_argument, nullptr, 'n' },
 …
         "wait for gdb to attach",                                                       // -g
         "print translator help message",                                        // -h
+        "invariant checking during AST passes",                         // -i
         "generate libcfa.c",                                                            // -l
         "generate line marks",                                                          // -L
 …
         { "rproto", resolvprotop, true, "resolver-proto instance" },
         { "rsteps", resolvep, true, "print resolver steps" },
-        { "tree", parsep, true, "print parse tree" },
         // code dumps
         { "ast", astp, true, "print AST after parsing" },
 …
                         usage( argv );                                                          // no return
                         break;
+                  case 'i':                                                                             // invariant checking
+                        invariant = true;
+                        break;
                   case 'l':                                                                             // generate libcfa.c
                         libcfap = true;
 …
 } // parse_cmdline
-static void parse( FILE * input, LinkageSpec::Spec linkage, bool shouldExit ) {
-        extern int yyparse( void );
-        extern FILE * yyin;
-        extern int yylineno;
-        ::linkage = linkage;                                                            // set globals
-        yyin = input;
-        yylineno = 1;
-        int parseStatus = yyparse();
-        fclose( input );
-        if ( shouldExit || parseStatus != 0 ) {
-                exit( parseStatus );
-        } // if
-} // parse
 static bool notPrelude( Declaration * decl ) {
         return ! LinkageSpec::isBuiltin( decl->get_linkage() );

tests/.expect/PRNG.x64.txt

-              r34b4268
+              r24d6572
+       PRNG()   PRNG(5)    PRNG(0,5)
+         3            0
+10137507171299805328         1            2
+12205946788447993741         4            0
+16222929371023265189         2            5
+11921944259646500358         1            1
+9511863719043198063         2            0
+18170109536749574203         0            1
+15896208456307578543         0            3
+4171113079117645375         1            4
+5535309872453329531         1            1
+13293369315461644140         2            2
+855811942427900360         1            1
+9125507373316195824         1            5
+6942856496042419510         1            5
+16774706561877323900         2            4
+17765436951300330249         4            0
+3766082030894719812         1            2
+15818141700523398820         3            5
+1244962761353699441         0            5
+4506898200126256218         1            2
+CFA xoshiro256pp
+                    PRNG()     PRNG(5)   PRNG(0,5)
+      13944458589275087071           3           2
+        129977468648444256           0           4
+       2357727400298891021           2           2
+       8855179187835660146           3           3
+       9957620185645882382           4           1
+      13396406983727409795           0           5
+       3342782395220265920           0           5
+       1707651271867677937           1           0
+      16402561450140881681           0           1
+      17838519215740313729           4           2
+       7425936020594490136           4           0
+       4174865704721714670           3           5
+      16055269689200152092           0           2
+      15091270195803594018           1           5
+      11807315541476180798           1           1
+      10697186588988060306           4           1
+      14665526411527044929           3           2
+      11289342279096164771           2           5
+      16126980828050300615           1           4
+       7821578301767524260           4           1
 seed 1009
 Sequential
 trials 100000000 buckets 100000 min 875 max 1138 avg 1000.0 std 31.8 rstd 3.2%
+trials 100000000 buckets 100000 min 875 max 1146 avg 1000.0 std 31.6 rstd 3.2%
 Concurrent
 trials 100000000 buckets 100000 min 875 max 1138 avg 1000.0 std 31.8 rstd 3.2%
 trials 100000000 buckets 100000 min 875 max 1138 avg 1000.0 std 31.8 rstd 3.2%
 trials 100000000 buckets 100000 min 875 max 1138 avg 1000.0 std 31.8 rstd 3.2%
 trials 100000000 buckets 100000 min 875 max 1138 avg 1000.0 std 31.8 rstd 3.2%
+trials 100000000 buckets 100000 min 875 max 1146 avg 1000.0 std 31.6 rstd 3.2%
+trials 100000000 buckets 100000 min 875 max 1146 avg 1000.0 std 31.6 rstd 3.2%
+trials 100000000 buckets 100000 min 875 max 1146 avg 1000.0 std 31.6 rstd 3.2%
+trials 100000000 buckets 100000 min 875 max 1146 avg 1000.0 std 31.6 rstd 3.2%
        prng()   prng(5)    prng(0,5)
          3            0
+10137507171299805328         1            2
+12205946788447993741         4            0
+16222929371023265189         2            5
 11921944259646500358         1            1
+9511863719043198063         2            0
+18170109536749574203         0            1
+15896208456307578543         0            3
+4171113079117645375         1            4
+5535309872453329531         1            1
+13293369315461644140         2            2
+855811942427900360         1            1
+9125507373316195824         1            5
 6942856496042419510         1            5
+16774706561877323900         2            4
+17765436951300330249         4            0
 3766082030894719812         1            2
 15818141700523398820         3            5
+1244962761353699441         0            5
+4506898200126256218         1            2
+                    prng()     prng(5)   prng(0,5)
+      13944458589275087071           3           2
+        129977468648444256           0           4
+       2357727400298891021           2           2
+       8855179187835660146           3           3
+       9957620185645882382           4           1
+      13396406983727409795           0           5
+       3342782395220265920           0           5
+       1707651271867677937           1           0
+      16402561450140881681           0           1
+      17838519215740313729           4           2
+       7425936020594490136           4           0
+       4174865704721714670           3           5
+      16055269689200152092           0           2
+      15091270195803594018           1           5
+      11807315541476180798           1           1
+      10697186588988060306           4           1
+      14665526411527044929           3           2
+      11289342279096164771           2           5
+      16126980828050300615           1           4
+       7821578301767524260           4           1
 seed 1009
 Sequential
 trials 100000000 buckets 100000 min 875 max 1138 avg 1000.0 std 31.8 rstd 3.2%
+trials 20000000 buckets 100000 min 139 max 265 avg 200.0 std 14.1 rstd 7.0%
 Concurrent
 trials 100000000 buckets 100000 min 875 max 1138 avg 1000.0 std 31.8 rstd 3.2%
 trials 100000000 buckets 100000 min 875 max 1138 avg 1000.0 std 31.8 rstd 3.2%
 trials 100000000 buckets 100000 min 875 max 1138 avg 1000.0 std 31.8 rstd 3.2%
 trials 100000000 buckets 100000 min 875 max 1138 avg 1000.0 std 31.8 rstd 3.2%
+trials 20000000 buckets 100000 min 139 max 265 avg 200.0 std 14.1 rstd 7.0%
+trials 20000000 buckets 100000 min 139 max 265 avg 200.0 std 14.1 rstd 7.0%
+trials 20000000 buckets 100000 min 139 max 265 avg 200.0 std 14.1 rstd 7.0%
+trials 20000000 buckets 100000 min 139 max 265 avg 200.0 std 14.1 rstd 7.0%
       prng(t) prng(t,5)  prng(t,0,5)
          3            0
+10137507171299805328         1            2
+12205946788447993741         4            0
+16222929371023265189         2            5
 11921944259646500358         1            1
+9511863719043198063         2            0
+18170109536749574203         0            1
+15896208456307578543         0            3
+4171113079117645375         1            4
+5535309872453329531         1            1
+13293369315461644140         2            2
+855811942427900360         1            1
+9125507373316195824         1            5
 6942856496042419510         1            5
+16774706561877323900         2            4
+17765436951300330249         4            0
 3766082030894719812         1            2
 15818141700523398820         3            5
+1244962761353699441         0            5
+4506898200126256218         1            2
+                   prng(t)   prng(t,5) prng(t,0,5)
+      13944458589275087071           3           2
+        129977468648444256           0           4
+       2357727400298891021           2           2
+       8855179187835660146           3           3
+       9957620185645882382           4           1
+      13396406983727409795           0           5
+       3342782395220265920           0           5
+       1707651271867677937           1           0
+      16402561450140881681           0           1
+      17838519215740313729           4           2
+       7425936020594490136           4           0
+       4174865704721714670           3           5
+      16055269689200152092           0           2
+      15091270195803594018           1           5
+      11807315541476180798           1           1
+      10697186588988060306           4           1
+      14665526411527044929           3           2
+      11289342279096164771           2           5
+      16126980828050300615           1           4
+       7821578301767524260           4           1
 seed 1009
 Sequential
 trials 100000000 buckets 100000 min 875 max 1138 avg 1000.0 std 31.8 rstd 3.2%
+trials 100000000 buckets 100000 min 875 max 1146 avg 1000.0 std 31.6 rstd 3.2%
 Concurrent
 trials 100000000 buckets 100000 min 875 max 1138 avg 1000.0 std 31.8 rstd 3.2%
 trials 100000000 buckets 100000 min 875 max 1138 avg 1000.0 std 31.8 rstd 3.2%
 trials 100000000 buckets 100000 min 875 max 1138 avg 1000.0 std 31.8 rstd 3.2%
 trials 100000000 buckets 100000 min 875 max 1138 avg 1000.0 std 31.8 rstd 3.2%
+trials 100000000 buckets 100000 min 875 max 1146 avg 1000.0 std 31.6 rstd 3.2%
+trials 100000000 buckets 100000 min 875 max 1146 avg 1000.0 std 31.6 rstd 3.2%
+trials 100000000 buckets 100000 min 875 max 1146 avg 1000.0 std 31.6 rstd 3.2%
+trials 100000000 buckets 100000 min 875 max 1146 avg 1000.0 std 31.6 rstd 3.2%

tests/.expect/PRNG.x86.txt

-              r34b4268
+              r24d6572
+       PRNG()   PRNG(5)    PRNG(0,5)
+      8333105         1            2
+   1989339636         4            5
+    266970699         3            2
+   1928130121         3            4
+   1351003938         4            5
+   1624164922         4            3
+    363429604         1            2
+   3355083174         1            1
+    214422584         1            1
+   2266729947         1            2
+   3649702519         2            4
+   2250875012         2            4
+   4184653025         1            3
+   2640851227         2            5
+    206468178         2            3
+   2600873108         1            3
+   3007574582         3            3
+    394476790         0            2
+   1312145388         1            5
+   2989081290         2            4
+CFA xoshiro128pp
+                    PRNG()     PRNG(5)   PRNG(0,5)
+                2884683541           0           0
+                3465286746           2           4
+                3268922916           0           1
+                2396374907           3           0
+                2135076892           4           1
+                 944377718           3           1
+                2204845346           3           3
+                3736609533           0           4
+                4063231336           0           2
+                1075394776           0           2
+                 712844808           4           0
+                4246343110           3           1
+                3793873837           2           1
+                3690340337           1           4
+                 319207944           1           4
+                1815791072           3           5
+                2581617261           1           5
+                3873329448           1           3
+                 832631329           4           0
+                 651551615           3           5
 seed 1009
 Sequential
 trials 100000000 buckets 100000 min 873 max 1140 avg 1000.0 std 31.3 rstd 3.1%
+trials 100000000 buckets 100000 min 858 max 1147 avg 1000.0 std 31.5 rstd 3.2%
 Concurrent
 trials 100000000 buckets 100000 min 873 max 1140 avg 1000.0 std 31.3 rstd 3.1%
 trials 100000000 buckets 100000 min 873 max 1140 avg 1000.0 std 31.3 rstd 3.1%
 trials 100000000 buckets 100000 min 873 max 1140 avg 1000.0 std 31.3 rstd 3.1%
 trials 100000000 buckets 100000 min 873 max 1140 avg 1000.0 std 31.3 rstd 3.1%
+trials 100000000 buckets 100000 min 858 max 1147 avg 1000.0 std 31.5 rstd 3.2%
+trials 100000000 buckets 100000 min 858 max 1147 avg 1000.0 std 31.5 rstd 3.2%
+trials 100000000 buckets 100000 min 858 max 1147 avg 1000.0 std 31.5 rstd 3.2%
+trials 100000000 buckets 100000 min 858 max 1147 avg 1000.0 std 31.5 rstd 3.2%
        prng()   prng(5)    prng(0,5)
       8333105         1            2
    1989339636         4            5
     266970699         3            2
    1928130121         3            4
    1351003938         4            5
    1624164922         4            3
     363429604         1            2
    3355083174         1            1
     214422584         1            1
    2266729947         1            2
    3649702519         2            4
    2250875012         2            4
    4184653025         1            3
    2640851227         2            5
     206468178         2            3
    2600873108         1            3
    3007574582         3            3
     394476790         0            2
    1312145388         1            5
    2989081290         2            4
+                    prng()     prng(5)   prng(0,5)
+                2884683541           0           0
+                3465286746           2           4
+                3268922916           0           1
+                2396374907           3           0
+                2135076892           4           1
+                 944377718           3           1
+                2204845346           3           3
+                3736609533           0           4
+                4063231336           0           2
+                1075394776           0           2
+                 712844808           4           0
+                4246343110           3           1
+                3793873837           2           1
+                3690340337           1           4
+                 319207944           1           4
+                1815791072           3           5
+                2581617261           1           5
+                3873329448           1           3
+                 832631329           4           0
+                 651551615           3           5
 seed 1009
 Sequential
 trials 100000000 buckets 100000 min 873 max 1140 avg 1000.0 std 31.3 rstd 3.1%
+trials 20000000 buckets 100000 min 144 max 270 avg 200.0 std 14.1 rstd 7.1%
 Concurrent
 trials 100000000 buckets 100000 min 873 max 1140 avg 1000.0 std 31.3 rstd 3.1%
 trials 100000000 buckets 100000 min 873 max 1140 avg 1000.0 std 31.3 rstd 3.1%
 trials 100000000 buckets 100000 min 873 max 1140 avg 1000.0 std 31.3 rstd 3.1%
 trials 100000000 buckets 100000 min 873 max 1140 avg 1000.0 std 31.3 rstd 3.1%
+trials 20000000 buckets 100000 min 144 max 270 avg 200.0 std 14.1 rstd 7.1%
+trials 20000000 buckets 100000 min 144 max 270 avg 200.0 std 14.1 rstd 7.1%
+trials 20000000 buckets 100000 min 144 max 270 avg 200.0 std 14.1 rstd 7.1%
+trials 20000000 buckets 100000 min 144 max 270 avg 200.0 std 14.1 rstd 7.1%
       prng(t) prng(t,5)  prng(t,0,5)
       8333105         1            2
    1989339636         4            5
     266970699         3            2
    1928130121         3            4
    1351003938         4            5
    1624164922         4            3
     363429604         1            2
    3355083174         1            1
     214422584         1            1
    2266729947         1            2
    3649702519         2            4
    2250875012         2            4
    4184653025         1            3
    2640851227         2            5
     206468178         2            3
    2600873108         1            3
    3007574582         3            3
     394476790         0            2
    1312145388         1            5
    2989081290         2            4
+                   prng(t)   prng(t,5) prng(t,0,5)
+                2884683541           0           0
+                3465286746           2           4
+                3268922916           0           1
+                2396374907           3           0
+                2135076892           4           1
+                 944377718           3           1
+                2204845346           3           3
+                3736609533           0           4
+                4063231336           0           2
+                1075394776           0           2
+                 712844808           4           0
+                4246343110           3           1
+                3793873837           2           1
+                3690340337           1           4
+                 319207944           1           4
+                1815791072           3           5
+                2581617261           1           5
+                3873329448           1           3
+                 832631329           4           0
+                 651551615           3           5
 seed 1009
 Sequential
 trials 100000000 buckets 100000 min 873 max 1140 avg 1000.0 std 31.3 rstd 3.1%
+trials 100000000 buckets 100000 min 858 max 1147 avg 1000.0 std 31.5 rstd 3.2%
 Concurrent
 trials 100000000 buckets 100000 min 873 max 1140 avg 1000.0 std 31.3 rstd 3.1%
 trials 100000000 buckets 100000 min 873 max 1140 avg 1000.0 std 31.3 rstd 3.1%
 trials 100000000 buckets 100000 min 873 max 1140 avg 1000.0 std 31.3 rstd 3.1%
 trials 100000000 buckets 100000 min 873 max 1140 avg 1000.0 std 31.3 rstd 3.1%
+trials 100000000 buckets 100000 min 858 max 1147 avg 1000.0 std 31.5 rstd 3.2%
+trials 100000000 buckets 100000 min 858 max 1147 avg 1000.0 std 31.5 rstd 3.2%
+trials 100000000 buckets 100000 min 858 max 1147 avg 1000.0 std 31.5 rstd 3.2%
+trials 100000000 buckets 100000 min 858 max 1147 avg 1000.0 std 31.5 rstd 3.2%

tests/.expect/array.txt

r34b4268	r24d6572
1		array.cfa:~~52:25: warning: Compil~~ed
	1	array.cfa:119:25: warning: Preprocessor started

tests/.expect/attributes.arm64.txt

-              r34b4268
+              r24d6572
     return _X4_retS12__anonymous0_1;
+}
 __attribute__ ((unused)) struct __anonymous0 _X5DummyS12__anonymous0_1;
+__attribute__ ((unused)) static struct __anonymous0 _X5DummyS12__anonymous0_1;
 struct __attribute__ ((unused)) Agn1;
 struct __attribute__ ((unused)) Agn2 {
 …
 signed int _X4apd5Fi_Fi_i_Fi_i___1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object12)(signed int __param_0), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object13)(signed int __param_0));
 signed int _X4apd6Fi_Fi__Fi____1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object14)(), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object15)());
 signed int _X4apd7Fi_Fi_i_Fi_i___1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object16)(signed int __param_0), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object17)(signed int __param_0));
+signed int _X4apd7Fi_Fi_i_Fi_i___1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object16)(__attribute__ ((unused)) signed int __param_0), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object17)(__attribute__ ((unused)) signed int __param_0));
 struct Vad {
     __attribute__ ((unused)) signed int :4;

tests/.expect/attributes.x64.txt

-              r34b4268
+              r24d6572
     return _X4_retS12__anonymous0_1;
+}
 __attribute__ ((unused)) struct __anonymous0 _X5DummyS12__anonymous0_1;
+__attribute__ ((unused)) static struct __anonymous0 _X5DummyS12__anonymous0_1;
 struct __attribute__ ((unused)) Agn1;
 struct __attribute__ ((unused)) Agn2 {
 …
 signed int _X4apd5Fi_Fi_i_Fi_i___1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object12)(signed int __param_0), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object13)(signed int __param_0));
 signed int _X4apd6Fi_Fi__Fi____1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object14)(), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object15)());
 signed int _X4apd7Fi_Fi_i_Fi_i___1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object16)(signed int __param_0), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object17)(signed int __param_0));
+signed int _X4apd7Fi_Fi_i_Fi_i___1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object16)(__attribute__ ((unused)) signed int __param_0), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object17)(__attribute__ ((unused)) signed int __param_0));
 struct Vad {
     __attribute__ ((unused)) signed int :4;

tests/.expect/attributes.x86.txt

-              r34b4268
+              r24d6572
     return _X4_retS12__anonymous0_1;
+}
 __attribute__ ((unused)) struct __anonymous0 _X5DummyS12__anonymous0_1;
+__attribute__ ((unused)) static struct __anonymous0 _X5DummyS12__anonymous0_1;
 struct __attribute__ ((unused)) Agn1;
 struct __attribute__ ((unused)) Agn2 {
 …
 signed int _X4apd5Fi_Fi_i_Fi_i___1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object12)(signed int __param_0), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object13)(signed int __param_0));
 signed int _X4apd6Fi_Fi__Fi____1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object14)(), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object15)());
 signed int _X4apd7Fi_Fi_i_Fi_i___1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object16)(signed int __param_0), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object17)(signed int __param_0));
+signed int _X4apd7Fi_Fi_i_Fi_i___1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object16)(__attribute__ ((unused)) signed int __param_0), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object17)(__attribute__ ((unused)) signed int __param_0));
 struct Vad {
     __attribute__ ((unused)) signed int :4;

tests/.expect/declarationSpecifier.arm64.txt

-              r34b4268
+              r24d6572
+}
 volatile const struct __anonymous0 _X3x10KVS12__anonymous0_1;
+static volatile const struct __anonymous0 _X3x10KVS12__anonymous0_1;
 struct __anonymous1 {
     signed int _X1ii_1;
 …
+}
 volatile const struct __anonymous1 _X3x11KVS12__anonymous1_1;
+static volatile const struct __anonymous1 _X3x11KVS12__anonymous1_1;
 struct __anonymous2 {
     signed int _X1ii_1;
 …
+}
 volatile const struct __anonymous2 _X3x12KVS12__anonymous2_1;
+static volatile const struct __anonymous2 _X3x12KVS12__anonymous2_1;
 struct __anonymous3 {
     signed int _X1ii_1;
 …
+}
 static volatile const struct __anonymous6 _X3x16KVS12__anonymous6_1;
-struct __anonymous7 {
-    signed int _X1ii_1;
-};
-static inline void _X12_constructorFv_S12__anonymous7_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1);
-static inline void _X12_constructorFv_S12__anonymous7S12__anonymous7_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1, struct __anonymous7 _X4_srcS12__anonymous7_1);
-static inline void _X11_destructorFv_S12__anonymous7_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1);
-static inline struct __anonymous7 _X16_operator_assignFS12__anonymous7_S12__anonymous7S12__anonymous7_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1, struct __anonymous7 _X4_srcS12__anonymous7_1);
-static inline void _X12_constructorFv_S12__anonymous7i_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1, signed int _X1ii_1);
-static inline void _X12_constructorFv_S12__anonymous7_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1){
+    {
-        ((void)((*_X4_dstS12__anonymous7_1)._X1ii_1) /* ?{} */);
+    }
+}
-static inline void _X12_constructorFv_S12__anonymous7S12__anonymous7_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1, struct __anonymous7 _X4_srcS12__anonymous7_1){
+    {
-        ((void)((*_X4_dstS12__anonymous7_1)._X1ii_1=_X4_srcS12__anonymous7_1._X1ii_1) /* ?{} */);
+    }
+}
-static inline void _X11_destructorFv_S12__anonymous7_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1){
+    {
-        ((void)((*_X4_dstS12__anonymous7_1)._X1ii_1) /* ^?{} */);
+    }
+}
-static inline struct __anonymous7 _X16_operator_assignFS12__anonymous7_S12__anonymous7S12__anonymous7_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1, struct __anonymous7 _X4_srcS12__anonymous7_1){
-    struct __anonymous7 _X4_retS12__anonymous7_1;
+    {
-        ((void)((*_X4_dstS12__anonymous7_1)._X1ii_1=_X4_srcS12__anonymous7_1._X1ii_1));
+    }
+    {
-        ((void)_X12_constructorFv_S12__anonymous7S12__anonymous7_autogen___1((&_X4_retS12__anonymous7_1), (*_X4_dstS12__anonymous7_1)));
+    }
-    return _X4_retS12__anonymous7_1;
+}
-static inline void _X12_constructorFv_S12__anonymous7i_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1, signed int _X1ii_1){
+    {
-        ((void)((*_X4_dstS12__anonymous7_1)._X1ii_1=_X1ii_1) /* ?{} */);
+    }
+}
-static volatile const struct __anonymous7 _X3x17KVS12__anonymous7_1;
 volatile const signed short int _X3x20KVs_1;
 static volatile const signed short int _X3x21KVs_1;
 …
 static volatile const signed short int _X3x26KVs_1;
 static volatile const signed short int _X3x27KVs_1;
+struct __anonymous7 {
+    signed short int _X1is_1;
+};
+static inline void _X12_constructorFv_S12__anonymous7_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1);
+static inline void _X12_constructorFv_S12__anonymous7S12__anonymous7_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1, struct __anonymous7 _X4_srcS12__anonymous7_1);
+static inline void _X11_destructorFv_S12__anonymous7_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1);
+static inline struct __anonymous7 _X16_operator_assignFS12__anonymous7_S12__anonymous7S12__anonymous7_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1, struct __anonymous7 _X4_srcS12__anonymous7_1);
+static inline void _X12_constructorFv_S12__anonymous7s_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1, signed short int _X1is_1);
+static inline void _X12_constructorFv_S12__anonymous7_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1){
+    {
+        ((void)((*_X4_dstS12__anonymous7_1)._X1is_1) /* ?{} */);
+    }
+}
+static inline void _X12_constructorFv_S12__anonymous7S12__anonymous7_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1, struct __anonymous7 _X4_srcS12__anonymous7_1){
+    {
+        ((void)((*_X4_dstS12__anonymous7_1)._X1is_1=_X4_srcS12__anonymous7_1._X1is_1) /* ?{} */);
+    }
+}
+static inline void _X11_destructorFv_S12__anonymous7_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1){
+    {
+        ((void)((*_X4_dstS12__anonymous7_1)._X1is_1) /* ^?{} */);
+    }
+}
+static inline struct __anonymous7 _X16_operator_assignFS12__anonymous7_S12__anonymous7S12__anonymous7_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1, struct __anonymous7 _X4_srcS12__anonymous7_1){
+    struct __anonymous7 _X4_retS12__anonymous7_1;
+    {
+        ((void)((*_X4_dstS12__anonymous7_1)._X1is_1=_X4_srcS12__anonymous7_1._X1is_1));
+    }
+    {
+        ((void)_X12_constructorFv_S12__anonymous7S12__anonymous7_autogen___1((&_X4_retS12__anonymous7_1), (*_X4_dstS12__anonymous7_1)));
+    }
+    return _X4_retS12__anonymous7_1;
+}
+static inline void _X12_constructorFv_S12__anonymous7s_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1, signed short int _X1is_1){
+    {
+        ((void)((*_X4_dstS12__anonymous7_1)._X1is_1=_X1is_1) /* ?{} */);
+    }
+}
+static volatile const struct __anonymous7 _X3x29KVS12__anonymous7_1;
 struct __anonymous8 {
     signed short int _X1is_1;
 …
+}
 volatile const struct __anonymous8 _X3x29KVS12__anonymous8_1;
+static volatile const struct __anonymous8 _X3x30KVS12__anonymous8_1;
 struct __anonymous9 {
     signed short int _X1is_1;
 …
+}
 volatile const struct __anonymous9 _X3x30KVS12__anonymous9_1;
+static volatile const struct __anonymous9 _X3x31KVS12__anonymous9_1;
 struct __anonymous10 {
     signed short int _X1is_1;
 …
+}
 volatile const struct __anonymous10 _X3x31KVS13__anonymous10_1;
+static volatile const struct __anonymous10 _X3x32KVS13__anonymous10_1;
 struct __anonymous11 {
     signed short int _X1is_1;
 …
+}
 static volatile const struct __anonymous11 _X3x32KVS13__anonymous11_1;
+static volatile const struct __anonymous11 _X3x33KVS13__anonymous11_1;
 struct __anonymous12 {
     signed short int _X1is_1;
 …
+}
 static volatile const struct __anonymous12 _X3x33KVS13__anonymous12_1;
+static volatile const struct __anonymous12 _X3x34KVS13__anonymous12_1;
 struct __anonymous13 {
     signed short int _X1is_1;
 …
+}
+static volatile const struct __anonymous13 _X3x34KVS13__anonymous13_1;
+struct __anonymous14 {
+    signed short int _X1is_1;
+};
+static inline void _X12_constructorFv_S13__anonymous14_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1);
+static inline void _X12_constructorFv_S13__anonymous14S13__anonymous14_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1, struct __anonymous14 _X4_srcS13__anonymous14_1);
+static inline void _X11_destructorFv_S13__anonymous14_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1);
+static inline struct __anonymous14 _X16_operator_assignFS13__anonymous14_S13__anonymous14S13__anonymous14_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1, struct __anonymous14 _X4_srcS13__anonymous14_1);
+static inline void _X12_constructorFv_S13__anonymous14s_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1, signed short int _X1is_1);
+static inline void _X12_constructorFv_S13__anonymous14_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1){
+    {
+        ((void)((*_X4_dstS13__anonymous14_1)._X1is_1) /* ?{} */);
+    }
+}
+static inline void _X12_constructorFv_S13__anonymous14S13__anonymous14_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1, struct __anonymous14 _X4_srcS13__anonymous14_1){
+    {
+        ((void)((*_X4_dstS13__anonymous14_1)._X1is_1=_X4_srcS13__anonymous14_1._X1is_1) /* ?{} */);
+    }
+}
+static inline void _X11_destructorFv_S13__anonymous14_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1){
+    {
+        ((void)((*_X4_dstS13__anonymous14_1)._X1is_1) /* ^?{} */);
+    }
+}
+static inline struct __anonymous14 _X16_operator_assignFS13__anonymous14_S13__anonymous14S13__anonymous14_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1, struct __anonymous14 _X4_srcS13__anonymous14_1){
+    struct __anonymous14 _X4_retS13__anonymous14_1;
+    {
+        ((void)((*_X4_dstS13__anonymous14_1)._X1is_1=_X4_srcS13__anonymous14_1._X1is_1));
+    }
+    {
+        ((void)_X12_constructorFv_S13__anonymous14S13__anonymous14_autogen___1((&_X4_retS13__anonymous14_1), (*_X4_dstS13__anonymous14_1)));
+    }
+    return _X4_retS13__anonymous14_1;
+}
+static inline void _X12_constructorFv_S13__anonymous14s_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1, signed short int _X1is_1){
+    {
+        ((void)((*_X4_dstS13__anonymous14_1)._X1is_1=_X1is_1) /* ?{} */);
+    }
+}
+static volatile const struct __anonymous14 _X3x35KVS13__anonymous14_1;
+struct __anonymous15 {
+    signed short int _X1is_1;
+};
+static inline void _X12_constructorFv_S13__anonymous15_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1);
+static inline void _X12_constructorFv_S13__anonymous15S13__anonymous15_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1, struct __anonymous15 _X4_srcS13__anonymous15_1);
+static inline void _X11_destructorFv_S13__anonymous15_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1);
+static inline struct __anonymous15 _X16_operator_assignFS13__anonymous15_S13__anonymous15S13__anonymous15_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1, struct __anonymous15 _X4_srcS13__anonymous15_1);
+static inline void _X12_constructorFv_S13__anonymous15s_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1, signed short int _X1is_1);
+static inline void _X12_constructorFv_S13__anonymous15_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1){
+    {
+        ((void)((*_X4_dstS13__anonymous15_1)._X1is_1) /* ?{} */);
+    }
+}
+static inline void _X12_constructorFv_S13__anonymous15S13__anonymous15_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1, struct __anonymous15 _X4_srcS13__anonymous15_1){
+    {
+        ((void)((*_X4_dstS13__anonymous15_1)._X1is_1=_X4_srcS13__anonymous15_1._X1is_1) /* ?{} */);
+    }
+}
+static inline void _X11_destructorFv_S13__anonymous15_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1){
+    {
+        ((void)((*_X4_dstS13__anonymous15_1)._X1is_1) /* ^?{} */);
+    }
+}
+static inline struct __anonymous15 _X16_operator_assignFS13__anonymous15_S13__anonymous15S13__anonymous15_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1, struct __anonymous15 _X4_srcS13__anonymous15_1){
+    struct __anonymous15 _X4_retS13__anonymous15_1;
+    {
+        ((void)((*_X4_dstS13__anonymous15_1)._X1is_1=_X4_srcS13__anonymous15_1._X1is_1));
+    }
+    {
+        ((void)_X12_constructorFv_S13__anonymous15S13__anonymous15_autogen___1((&_X4_retS13__anonymous15_1), (*_X4_dstS13__anonymous15_1)));
+    }
+    return _X4_retS13__anonymous15_1;
+}
+static inline void _X12_constructorFv_S13__anonymous15s_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1, signed short int _X1is_1){
+    {
+        ((void)((*_X4_dstS13__anonymous15_1)._X1is_1=_X1is_1) /* ?{} */);
+    }
+}
+static volatile const struct __anonymous15 _X3x36KVS13__anonymous15_1;
+static volatile const struct __anonymous13 _X3x35KVS13__anonymous13_1;
 _Thread_local signed int _X3x37i_1;
 __thread signed int _X3x38i_1;
 …
 static inline volatile const signed short int _X3f27Fs___1();
 static inline volatile const signed short int _X3f28Fs___1();
+struct __anonymous14 {
+    signed int _X1ii_1;
+};
+static inline void _X12_constructorFv_S13__anonymous14_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1);
+static inline void _X12_constructorFv_S13__anonymous14S13__anonymous14_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1, struct __anonymous14 _X4_srcS13__anonymous14_1);
+static inline void _X11_destructorFv_S13__anonymous14_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1);
+static inline struct __anonymous14 _X16_operator_assignFS13__anonymous14_S13__anonymous14S13__anonymous14_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1, struct __anonymous14 _X4_srcS13__anonymous14_1);
+static inline void _X12_constructorFv_S13__anonymous14i_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1, signed int _X1ii_1);
+static inline void _X12_constructorFv_S13__anonymous14_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1){
+    {
+        ((void)((*_X4_dstS13__anonymous14_1)._X1ii_1) /* ?{} */);
+    }
+}
+static inline void _X12_constructorFv_S13__anonymous14S13__anonymous14_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1, struct __anonymous14 _X4_srcS13__anonymous14_1){
+    {
+        ((void)((*_X4_dstS13__anonymous14_1)._X1ii_1=_X4_srcS13__anonymous14_1._X1ii_1) /* ?{} */);
+    }
+}
+static inline void _X11_destructorFv_S13__anonymous14_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1){
+    {
+        ((void)((*_X4_dstS13__anonymous14_1)._X1ii_1) /* ^?{} */);
+    }
+}
+static inline struct __anonymous14 _X16_operator_assignFS13__anonymous14_S13__anonymous14S13__anonymous14_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1, struct __anonymous14 _X4_srcS13__anonymous14_1){
+    struct __anonymous14 _X4_retS13__anonymous14_1;
+    {
+        ((void)((*_X4_dstS13__anonymous14_1)._X1ii_1=_X4_srcS13__anonymous14_1._X1ii_1));
+    }
+    {
+        ((void)_X12_constructorFv_S13__anonymous14S13__anonymous14_autogen___1((&_X4_retS13__anonymous14_1), (*_X4_dstS13__anonymous14_1)));
+    }
+    return _X4_retS13__anonymous14_1;
+}
+static inline void _X12_constructorFv_S13__anonymous14i_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1, signed int _X1ii_1){
+    {
+        ((void)((*_X4_dstS13__anonymous14_1)._X1ii_1=_X1ii_1) /* ?{} */);
+    }
+}
+static inline volatile const struct __anonymous14 _X3f31FS13__anonymous14___1();
+struct __anonymous15 {
+    signed int _X1ii_1;
+};
+static inline void _X12_constructorFv_S13__anonymous15_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1);
+static inline void _X12_constructorFv_S13__anonymous15S13__anonymous15_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1, struct __anonymous15 _X4_srcS13__anonymous15_1);
+static inline void _X11_destructorFv_S13__anonymous15_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1);
+static inline struct __anonymous15 _X16_operator_assignFS13__anonymous15_S13__anonymous15S13__anonymous15_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1, struct __anonymous15 _X4_srcS13__anonymous15_1);
+static inline void _X12_constructorFv_S13__anonymous15i_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1, signed int _X1ii_1);
+static inline void _X12_constructorFv_S13__anonymous15_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1){
+    {
+        ((void)((*_X4_dstS13__anonymous15_1)._X1ii_1) /* ?{} */);
+    }
+}
+static inline void _X12_constructorFv_S13__anonymous15S13__anonymous15_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1, struct __anonymous15 _X4_srcS13__anonymous15_1){
+    {
+        ((void)((*_X4_dstS13__anonymous15_1)._X1ii_1=_X4_srcS13__anonymous15_1._X1ii_1) /* ?{} */);
+    }
+}
+static inline void _X11_destructorFv_S13__anonymous15_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1){
+    {
+        ((void)((*_X4_dstS13__anonymous15_1)._X1ii_1) /* ^?{} */);
+    }
+}
+static inline struct __anonymous15 _X16_operator_assignFS13__anonymous15_S13__anonymous15S13__anonymous15_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1, struct __anonymous15 _X4_srcS13__anonymous15_1){
+    struct __anonymous15 _X4_retS13__anonymous15_1;
+    {
+        ((void)((*_X4_dstS13__anonymous15_1)._X1ii_1=_X4_srcS13__anonymous15_1._X1ii_1));
+    }
+    {
+        ((void)_X12_constructorFv_S13__anonymous15S13__anonymous15_autogen___1((&_X4_retS13__anonymous15_1), (*_X4_dstS13__anonymous15_1)));
+    }
+    return _X4_retS13__anonymous15_1;
+}
+static inline void _X12_constructorFv_S13__anonymous15i_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1, signed int _X1ii_1){
+    {
+        ((void)((*_X4_dstS13__anonymous15_1)._X1ii_1=_X1ii_1) /* ?{} */);
+    }
+}
+static inline volatile const struct __anonymous15 _X3f32FS13__anonymous15___1();
 struct __anonymous16 {
     signed int _X1ii_1;
 …
+}
 static inline volatile const struct __anonymous16 _X3f31FS13__anonymous16___1();
+static inline volatile const struct __anonymous16 _X3f33FS13__anonymous16___1();
 struct __anonymous17 {
     signed int _X1ii_1;
 …
+}
 static inline volatile const struct __anonymous17 _X3f32FS13__anonymous17___1();
+static inline volatile const struct __anonymous17 _X3f34FS13__anonymous17___1();
 struct __anonymous18 {
     signed int _X1ii_1;
 …
+}
 static inline volatile const struct __anonymous18 _X3f33FS13__anonymous18___1();
+static inline volatile const struct __anonymous18 _X3f35FS13__anonymous18___1();
 struct __anonymous19 {
     signed int _X1ii_1;
 …
+}
 static inline volatile const struct __anonymous19 _X3f34FS13__anonymous19___1();
+static inline volatile const struct __anonymous19 _X3f36FS13__anonymous19___1();
 struct __anonymous20 {
     signed int _X1ii_1;
 …
+}
 static inline volatile const struct __anonymous20 _X3f35FS13__anonymous20___1();
+static inline volatile const struct __anonymous20 _X3f37FS13__anonymous20___1();
 struct __anonymous21 {
     signed int _X1ii_1;
 …
+}
+static inline volatile const struct __anonymous21 _X3f36FS13__anonymous21___1();
+struct __anonymous22 {
+    signed int _X1ii_1;
+};
+static inline void _X12_constructorFv_S13__anonymous22_autogen___1(struct __anonymous22 *_X4_dstS13__anonymous22_1);
+static inline void _X12_constructorFv_S13__anonymous22S13__anonymous22_autogen___1(struct __anonymous22 *_X4_dstS13__anonymous22_1, struct __anonymous22 _X4_srcS13__anonymous22_1);
+static inline void _X11_destructorFv_S13__anonymous22_autogen___1(struct __anonymous22 *_X4_dstS13__anonymous22_1);
+static inline struct __anonymous22 _X16_operator_assignFS13__anonymous22_S13__anonymous22S13__anonymous22_autogen___1(struct __anonymous22 *_X4_dstS13__anonymous22_1, struct __anonymous22 _X4_srcS13__anonymous22_1);
+static inline void _X12_constructorFv_S13__anonymous22i_autogen___1(struct __anonymous22 *_X4_dstS13__anonymous22_1, signed int _X1ii_1);
+static inline void _X12_constructorFv_S13__anonymous22_autogen___1(struct __anonymous22 *_X4_dstS13__anonymous22_1){
+    {
+        ((void)((*_X4_dstS13__anonymous22_1)._X1ii_1) /* ?{} */);
+    }
+}
+static inline void _X12_constructorFv_S13__anonymous22S13__anonymous22_autogen___1(struct __anonymous22 *_X4_dstS13__anonymous22_1, struct __anonymous22 _X4_srcS13__anonymous22_1){
+    {
+        ((void)((*_X4_dstS13__anonymous22_1)._X1ii_1=_X4_srcS13__anonymous22_1._X1ii_1) /* ?{} */);
+    }
+}
+static inline void _X11_destructorFv_S13__anonymous22_autogen___1(struct __anonymous22 *_X4_dstS13__anonymous22_1){
+    {
+        ((void)((*_X4_dstS13__anonymous22_1)._X1ii_1) /* ^?{} */);
+    }
+}
+static inline struct __anonymous22 _X16_operator_assignFS13__anonymous22_S13__anonymous22S13__anonymous22_autogen___1(struct __anonymous22 *_X4_dstS13__anonymous22_1, struct __anonymous22 _X4_srcS13__anonymous22_1){
+    struct __anonymous22 _X4_retS13__anonymous22_1;
+    {
+        ((void)((*_X4_dstS13__anonymous22_1)._X1ii_1=_X4_srcS13__anonymous22_1._X1ii_1));
+    }
+    {
+        ((void)_X12_constructorFv_S13__anonymous22S13__anonymous22_autogen___1((&_X4_retS13__anonymous22_1), (*_X4_dstS13__anonymous22_1)));
+    }
+    return _X4_retS13__anonymous22_1;
+}
+static inline void _X12_constructorFv_S13__anonymous22i_autogen___1(struct __anonymous22 *_X4_dstS13__anonymous22_1, signed int _X1ii_1){
+    {
+        ((void)((*_X4_dstS13__anonymous22_1)._X1ii_1=_X1ii_1) /* ?{} */);
+    }
+}
+static inline volatile const struct __anonymous22 _X3f37FS13__anonymous22___1();
+struct __anonymous23 {
+    signed int _X1ii_1;
+};
+static inline void _X12_constructorFv_S13__anonymous23_autogen___1(struct __anonymous23 *_X4_dstS13__anonymous23_1);
+static inline void _X12_constructorFv_S13__anonymous23S13__anonymous23_autogen___1(struct __anonymous23 *_X4_dstS13__anonymous23_1, struct __anonymous23 _X4_srcS13__anonymous23_1);
+static inline void _X11_destructorFv_S13__anonymous23_autogen___1(struct __anonymous23 *_X4_dstS13__anonymous23_1);
+static inline struct __anonymous23 _X16_operator_assignFS13__anonymous23_S13__anonymous23S13__anonymous23_autogen___1(struct __anonymous23 *_X4_dstS13__anonymous23_1, struct __anonymous23 _X4_srcS13__anonymous23_1);
+static inline void _X12_constructorFv_S13__anonymous23i_autogen___1(struct __anonymous23 *_X4_dstS13__anonymous23_1, signed int _X1ii_1);
+static inline void _X12_constructorFv_S13__anonymous23_autogen___1(struct __anonymous23 *_X4_dstS13__anonymous23_1){
+    {
+        ((void)((*_X4_dstS13__anonymous23_1)._X1ii_1) /* ?{} */);
+    }
+}
+static inline void _X12_constructorFv_S13__anonymous23S13__anonymous23_autogen___1(struct __anonymous23 *_X4_dstS13__anonymous23_1, struct __anonymous23 _X4_srcS13__anonymous23_1){
+    {
+        ((void)((*_X4_dstS13__anonymous23_1)._X1ii_1=_X4_srcS13__anonymous23_1._X1ii_1) /* ?{} */);
+    }
+}
+static inline void _X11_destructorFv_S13__anonymous23_autogen___1(struct __anonymous23 *_X4_dstS13__anonymous23_1){
+    {
+        ((void)((*_X4_dstS13__anonymous23_1)._X1ii_1) /* ^?{} */);
+    }
+}
+static inline struct __anonymous23 _X16_operator_assignFS13__anonymous23_S13__anonymous23S13__anonymous23_autogen___1(struct __anonymous23 *_X4_dstS13__anonymous23_1, struct __anonymous23 _X4_srcS13__anonymous23_1){
+    struct __anonymous23 _X4_retS13__anonymous23_1;
+    {
+        ((void)((*_X4_dstS13__anonymous23_1)._X1ii_1=_X4_srcS13__anonymous23_1._X1ii_1));
+    }
+    {
+        ((void)_X12_constructorFv_S13__anonymous23S13__anonymous23_autogen___1((&_X4_retS13__anonymous23_1), (*_X4_dstS13__anonymous23_1)));
+    }
+    return _X4_retS13__anonymous23_1;
+}
+static inline void _X12_constructorFv_S13__anonymous23i_autogen___1(struct __anonymous23 *_X4_dstS13__anonymous23_1, signed int _X1ii_1){
+    {
+        ((void)((*_X4_dstS13__anonymous23_1)._X1ii_1=_X1ii_1) /* ?{} */);
+    }
+}
+static inline volatile const struct __anonymous23 _X3f38FS13__anonymous23___1();
+static inline volatile const struct __anonymous21 _X3f38FS13__anonymous21___1();
 static inline volatile const signed short int _X3f41Fs___1();
 static inline volatile const signed short int _X3f42Fs___1();

tests/.expect/declarationSpecifier.x64.txt

-              r34b4268
+              r24d6572
+}
 volatile const struct __anonymous0 _X3x10KVS12__anonymous0_1;
+static volatile const struct __anonymous0 _X3x10KVS12__anonymous0_1;
 struct __anonymous1 {
     signed int _X1ii_1;
 …
+}
 volatile const struct __anonymous1 _X3x11KVS12__anonymous1_1;
+static volatile const struct __anonymous1 _X3x11KVS12__anonymous1_1;
 struct __anonymous2 {
     signed int _X1ii_1;
 …
+}
 volatile const struct __anonymous2 _X3x12KVS12__anonymous2_1;
+static volatile const struct __anonymous2 _X3x12KVS12__anonymous2_1;
 struct __anonymous3 {
     signed int _X1ii_1;
 …
+}
 static volatile const struct __anonymous6 _X3x16KVS12__anonymous6_1;
-struct __anonymous7 {
-    signed int _X1ii_1;
-};
-static inline void _X12_constructorFv_S12__anonymous7_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1);
-static inline void _X12_constructorFv_S12__anonymous7S12__anonymous7_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1, struct __anonymous7 _X4_srcS12__anonymous7_1);
-static inline void _X11_destructorFv_S12__anonymous7_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1);
-static inline struct __anonymous7 _X16_operator_assignFS12__anonymous7_S12__anonymous7S12__anonymous7_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1, struct __anonymous7 _X4_srcS12__anonymous7_1);
-static inline void _X12_constructorFv_S12__anonymous7i_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1, signed int _X1ii_1);
-static inline void _X12_constructorFv_S12__anonymous7_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1){
+    {
-        ((void)((*_X4_dstS12__anonymous7_1)._X1ii_1) /* ?{} */);
+    }
+}
-static inline void _X12_constructorFv_S12__anonymous7S12__anonymous7_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1, struct __anonymous7 _X4_srcS12__anonymous7_1){
+    {
-        ((void)((*_X4_dstS12__anonymous7_1)._X1ii_1=_X4_srcS12__anonymous7_1._X1ii_1) /* ?{} */);
+    }
+}
-static inline void _X11_destructorFv_S12__anonymous7_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1){
+    {
-        ((void)((*_X4_dstS12__anonymous7_1)._X1ii_1) /* ^?{} */);
+    }
+}
-static inline struct __anonymous7 _X16_operator_assignFS12__anonymous7_S12__anonymous7S12__anonymous7_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1, struct __anonymous7 _X4_srcS12__anonymous7_1){
-    struct __anonymous7 _X4_retS12__anonymous7_1;
+    {
-        ((void)((*_X4_dstS12__anonymous7_1)._X1ii_1=_X4_srcS12__anonymous7_1._X1ii_1));
+    }
+    {
-        ((void)_X12_constructorFv_S12__anonymous7S12__anonymous7_autogen___1((&_X4_retS12__anonymous7_1), (*_X4_dstS12__anonymous7_1)));
+    }
-    return _X4_retS12__anonymous7_1;
+}
-static inline void _X12_constructorFv_S12__anonymous7i_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1, signed int _X1ii_1){
+    {
-        ((void)((*_X4_dstS12__anonymous7_1)._X1ii_1=_X1ii_1) /* ?{} */);
+    }
+}
-static volatile const struct __anonymous7 _X3x17KVS12__anonymous7_1;
 volatile const signed short int _X3x20KVs_1;
 static volatile const signed short int _X3x21KVs_1;
 …
 static volatile const signed short int _X3x26KVs_1;
 static volatile const signed short int _X3x27KVs_1;
+struct __anonymous7 {
+    signed short int _X1is_1;
+};
+static inline void _X12_constructorFv_S12__anonymous7_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1);
+static inline void _X12_constructorFv_S12__anonymous7S12__anonymous7_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1, struct __anonymous7 _X4_srcS12__anonymous7_1);
+static inline void _X11_destructorFv_S12__anonymous7_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1);
+static inline struct __anonymous7 _X16_operator_assignFS12__anonymous7_S12__anonymous7S12__anonymous7_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1, struct __anonymous7 _X4_srcS12__anonymous7_1);
+static inline void _X12_constructorFv_S12__anonymous7s_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1, signed short int _X1is_1);
+static inline void _X12_constructorFv_S12__anonymous7_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1){
+    {
+        ((void)((*_X4_dstS12__anonymous7_1)._X1is_1) /* ?{} */);
+    }
+}
+static inline void _X12_constructorFv_S12__anonymous7S12__anonymous7_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1, struct __anonymous7 _X4_srcS12__anonymous7_1){
+    {
+        ((void)((*_X4_dstS12__anonymous7_1)._X1is_1=_X4_srcS12__anonymous7_1._X1is_1) /* ?{} */);
+    }
+}
+static inline void _X11_destructorFv_S12__anonymous7_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1){
+    {
+        ((void)((*_X4_dstS12__anonymous7_1)._X1is_1) /* ^?{} */);
+    }
+}
+static inline struct __anonymous7 _X16_operator_assignFS12__anonymous7_S12__anonymous7S12__anonymous7_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1, struct __anonymous7 _X4_srcS12__anonymous7_1){
+    struct __anonymous7 _X4_retS12__anonymous7_1;
+    {
+        ((void)((*_X4_dstS12__anonymous7_1)._X1is_1=_X4_srcS12__anonymous7_1._X1is_1));
+    }
+    {
+        ((void)_X12_constructorFv_S12__anonymous7S12__anonymous7_autogen___1((&_X4_retS12__anonymous7_1), (*_X4_dstS12__anonymous7_1)));
+    }
+    return _X4_retS12__anonymous7_1;
+}
+static inline void _X12_constructorFv_S12__anonymous7s_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1, signed short int _X1is_1){
+    {
+        ((void)((*_X4_dstS12__anonymous7_1)._X1is_1=_X1is_1) /* ?{} */);
+    }
+}
+static volatile const struct __anonymous7 _X3x29KVS12__anonymous7_1;
 struct __anonymous8 {
     signed short int _X1is_1;
 …
+}
 volatile const struct __anonymous8 _X3x29KVS12__anonymous8_1;
+static volatile const struct __anonymous8 _X3x30KVS12__anonymous8_1;
 struct __anonymous9 {
     signed short int _X1is_1;
 …
+}
 volatile const struct __anonymous9 _X3x30KVS12__anonymous9_1;
+static volatile const struct __anonymous9 _X3x31KVS12__anonymous9_1;
 struct __anonymous10 {
     signed short int _X1is_1;
 …
+}
 volatile const struct __anonymous10 _X3x31KVS13__anonymous10_1;
+static volatile const struct __anonymous10 _X3x32KVS13__anonymous10_1;
 struct __anonymous11 {
     signed short int _X1is_1;
 …
+}
 static volatile const struct __anonymous11 _X3x32KVS13__anonymous11_1;
+static volatile const struct __anonymous11 _X3x33KVS13__anonymous11_1;
 struct __anonymous12 {
     signed short int _X1is_1;
 …
+}
 static volatile const struct __anonymous12 _X3x33KVS13__anonymous12_1;
+static volatile const struct __anonymous12 _X3x34KVS13__anonymous12_1;
 struct __anonymous13 {
     signed short int _X1is_1;
 …
+}
+static volatile const struct __anonymous13 _X3x34KVS13__anonymous13_1;
+struct __anonymous14 {
+    signed short int _X1is_1;
+};
+static inline void _X12_constructorFv_S13__anonymous14_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1);
+static inline void _X12_constructorFv_S13__anonymous14S13__anonymous14_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1, struct __anonymous14 _X4_srcS13__anonymous14_1);
+static inline void _X11_destructorFv_S13__anonymous14_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1);
+static inline struct __anonymous14 _X16_operator_assignFS13__anonymous14_S13__anonymous14S13__anonymous14_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1, struct __anonymous14 _X4_srcS13__anonymous14_1);
+static inline void _X12_constructorFv_S13__anonymous14s_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1, signed short int _X1is_1);
+static inline void _X12_constructorFv_S13__anonymous14_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1){
+    {
+        ((void)((*_X4_dstS13__anonymous14_1)._X1is_1) /* ?{} */);
+    }
+}
+static inline void _X12_constructorFv_S13__anonymous14S13__anonymous14_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1, struct __anonymous14 _X4_srcS13__anonymous14_1){
+    {
+        ((void)((*_X4_dstS13__anonymous14_1)._X1is_1=_X4_srcS13__anonymous14_1._X1is_1) /* ?{} */);
+    }
+}
+static inline void _X11_destructorFv_S13__anonymous14_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1){
+    {
+        ((void)((*_X4_dstS13__anonymous14_1)._X1is_1) /* ^?{} */);
+    }
+}
+static inline struct __anonymous14 _X16_operator_assignFS13__anonymous14_S13__anonymous14S13__anonymous14_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1, struct __anonymous14 _X4_srcS13__anonymous14_1){
+    struct __anonymous14 _X4_retS13__anonymous14_1;
+    {
+        ((void)((*_X4_dstS13__anonymous14_1)._X1is_1=_X4_srcS13__anonymous14_1._X1is_1));
+    }
+    {
+        ((void)_X12_constructorFv_S13__anonymous14S13__anonymous14_autogen___1((&_X4_retS13__anonymous14_1), (*_X4_dstS13__anonymous14_1)));
+    }
+    return _X4_retS13__anonymous14_1;
+}
+static inline void _X12_constructorFv_S13__anonymous14s_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1, signed short int _X1is_1){
+    {
+        ((void)((*_X4_dstS13__anonymous14_1)._X1is_1=_X1is_1) /* ?{} */);
+    }
+}
+static volatile const struct __anonymous14 _X3x35KVS13__anonymous14_1;
+struct __anonymous15 {
+    signed short int _X1is_1;
+};
+static inline void _X12_constructorFv_S13__anonymous15_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1);
+static inline void _X12_constructorFv_S13__anonymous15S13__anonymous15_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1, struct __anonymous15 _X4_srcS13__anonymous15_1);
+static inline void _X11_destructorFv_S13__anonymous15_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1);
+static inline struct __anonymous15 _X16_operator_assignFS13__anonymous15_S13__anonymous15S13__anonymous15_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1, struct __anonymous15 _X4_srcS13__anonymous15_1);
+static inline void _X12_constructorFv_S13__anonymous15s_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1, signed short int _X1is_1);
+static inline void _X12_constructorFv_S13__anonymous15_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1){
+    {
+        ((void)((*_X4_dstS13__anonymous15_1)._X1is_1) /* ?{} */);
+    }
+}
+static inline void _X12_constructorFv_S13__anonymous15S13__anonymous15_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1, struct __anonymous15 _X4_srcS13__anonymous15_1){
+    {
+        ((void)((*_X4_dstS13__anonymous15_1)._X1is_1=_X4_srcS13__anonymous15_1._X1is_1) /* ?{} */);
+    }
+}
+static inline void _X11_destructorFv_S13__anonymous15_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1){
+    {
+        ((void)((*_X4_dstS13__anonymous15_1)._X1is_1) /* ^?{} */);
+    }
+}
+static inline struct __anonymous15 _X16_operator_assignFS13__anonymous15_S13__anonymous15S13__anonymous15_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1, struct __anonymous15 _X4_srcS13__anonymous15_1){
+    struct __anonymous15 _X4_retS13__anonymous15_1;
+    {
+        ((void)((*_X4_dstS13__anonymous15_1)._X1is_1=_X4_srcS13__anonymous15_1._X1is_1));
+    }
+    {
+        ((void)_X12_constructorFv_S13__anonymous15S13__anonymous15_autogen___1((&_X4_retS13__anonymous15_1), (*_X4_dstS13__anonymous15_1)));
+    }
+    return _X4_retS13__anonymous15_1;
+}
+static inline void _X12_constructorFv_S13__anonymous15s_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1, signed short int _X1is_1){
+    {
+        ((void)((*_X4_dstS13__anonymous15_1)._X1is_1=_X1is_1) /* ?{} */);
+    }
+}
+static volatile const struct __anonymous15 _X3x36KVS13__anonymous15_1;
+static volatile const struct __anonymous13 _X3x35KVS13__anonymous13_1;
 _Thread_local signed int _X3x37i_1;
 __thread signed int _X3x38i_1;
 …
 static inline volatile const signed short int _X3f27Fs___1();
 static inline volatile const signed short int _X3f28Fs___1();
+struct __anonymous14 {
+    signed int _X1ii_1;
+};
+static inline void _X12_constructorFv_S13__anonymous14_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1);
+static inline void _X12_constructorFv_S13__anonymous14S13__anonymous14_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1, struct __anonymous14 _X4_srcS13__anonymous14_1);
+static inline void _X11_destructorFv_S13__anonymous14_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1);
+static inline struct __anonymous14 _X16_operator_assignFS13__anonymous14_S13__anonymous14S13__anonymous14_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1, struct __anonymous14 _X4_srcS13__anonymous14_1);
+static inline void _X12_constructorFv_S13__anonymous14i_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1, signed int _X1ii_1);
+static inline void _X12_constructorFv_S13__anonymous14_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1){
+    {
+        ((void)((*_X4_dstS13__anonymous14_1)._X1ii_1) /* ?{} */);
+    }
+}
+static inline void _X12_constructorFv_S13__anonymous14S13__anonymous14_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1, struct __anonymous14 _X4_srcS13__anonymous14_1){
+    {
+        ((void)((*_X4_dstS13__anonymous14_1)._X1ii_1=_X4_srcS13__anonymous14_1._X1ii_1) /* ?{} */);
+    }
+}
+static inline void _X11_destructorFv_S13__anonymous14_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1){
+    {
+        ((void)((*_X4_dstS13__anonymous14_1)._X1ii_1) /* ^?{} */);
+    }
+}
+static inline struct __anonymous14 _X16_operator_assignFS13__anonymous14_S13__anonymous14S13__anonymous14_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1, struct __anonymous14 _X4_srcS13__anonymous14_1){
+    struct __anonymous14 _X4_retS13__anonymous14_1;
+    {
+        ((void)((*_X4_dstS13__anonymous14_1)._X1ii_1=_X4_srcS13__anonymous14_1._X1ii_1));
+    }
+    {
+        ((void)_X12_constructorFv_S13__anonymous14S13__anonymous14_autogen___1((&_X4_retS13__anonymous14_1), (*_X4_dstS13__anonymous14_1)));
+    }
+    return _X4_retS13__anonymous14_1;
+}
+static inline void _X12_constructorFv_S13__anonymous14i_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1, signed int _X1ii_1){
+    {
+        ((void)((*_X4_dstS13__anonymous14_1)._X1ii_1=_X1ii_1) /* ?{} */);
+    }
+}
+static inline volatile const struct __anonymous14 _X3f31FS13__anonymous14___1();
+struct __anonymous15 {
+    signed int _X1ii_1;
+};
+static inline void _X12_constructorFv_S13__anonymous15_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1);
+static inline void _X12_constructorFv_S13__anonymous15S13__anonymous15_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1, struct __anonymous15 _X4_srcS13__anonymous15_1);
+static inline void _X11_destructorFv_S13__anonymous15_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1);
+static inline struct __anonymous15 _X16_operator_assignFS13__anonymous15_S13__anonymous15S13__anonymous15_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1, struct __anonymous15 _X4_srcS13__anonymous15_1);
+static inline void _X12_constructorFv_S13__anonymous15i_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1, signed int _X1ii_1);
+static inline void _X12_constructorFv_S13__anonymous15_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1){
+    {
+        ((void)((*_X4_dstS13__anonymous15_1)._X1ii_1) /* ?{} */);
+    }
+}
+static inline void _X12_constructorFv_S13__anonymous15S13__anonymous15_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1, struct __anonymous15 _X4_srcS13__anonymous15_1){
+    {
+        ((void)((*_X4_dstS13__anonymous15_1)._X1ii_1=_X4_srcS13__anonymous15_1._X1ii_1) /* ?{} */);
+    }
+}
+static inline void _X11_destructorFv_S13__anonymous15_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1){
+    {
+        ((void)((*_X4_dstS13__anonymous15_1)._X1ii_1) /* ^?{} */);
+    }
+}
+static inline struct __anonymous15 _X16_operator_assignFS13__anonymous15_S13__anonymous15S13__anonymous15_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1, struct __anonymous15 _X4_srcS13__anonymous15_1){
+    struct __anonymous15 _X4_retS13__anonymous15_1;
+    {
+        ((void)((*_X4_dstS13__anonymous15_1)._X1ii_1=_X4_srcS13__anonymous15_1._X1ii_1));
+    }
+    {
+        ((void)_X12_constructorFv_S13__anonymous15S13__anonymous15_autogen___1((&_X4_retS13__anonymous15_1), (*_X4_dstS13__anonymous15_1)));
+    }
+    return _X4_retS13__anonymous15_1;
+}
+static inline void _X12_constructorFv_S13__anonymous15i_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1, signed int _X1ii_1){
+    {
+        ((void)((*_X4_dstS13__anonymous15_1)._X1ii_1=_X1ii_1) /* ?{} */);
+    }
+}
+static inline volatile const struct __anonymous15 _X3f32FS13__anonymous15___1();
 struct __anonymous16 {
     signed int _X1ii_1;
 …
+}
 static inline volatile const struct __anonymous16 _X3f31FS13__anonymous16___1();
+static inline volatile const struct __anonymous16 _X3f33FS13__anonymous16___1();
 struct __anonymous17 {
     signed int _X1ii_1;
 …
+}
 static inline volatile const struct __anonymous17 _X3f32FS13__anonymous17___1();
+static inline volatile const struct __anonymous17 _X3f34FS13__anonymous17___1();
 struct __anonymous18 {
     signed int _X1ii_1;
 …
+}
 static inline volatile const struct __anonymous18 _X3f33FS13__anonymous18___1();
+static inline volatile const struct __anonymous18 _X3f35FS13__anonymous18___1();
 struct __anonymous19 {
     signed int _X1ii_1;
 …
+}
 static inline volatile const struct __anonymous19 _X3f34FS13__anonymous19___1();
+static inline volatile const struct __anonymous19 _X3f36FS13__anonymous19___1();
 struct __anonymous20 {
     signed int _X1ii_1;
 …
+}
 static inline volatile const struct __anonymous20 _X3f35FS13__anonymous20___1();
+static inline volatile const struct __anonymous20 _X3f37FS13__anonymous20___1();
 struct __anonymous21 {
     signed int _X1ii_1;
 …
+}
+static inline volatile const struct __anonymous21 _X3f36FS13__anonymous21___1();
+struct __anonymous22 {
+    signed int _X1ii_1;
+};
+static inline void _X12_constructorFv_S13__anonymous22_autogen___1(struct __anonymous22 *_X4_dstS13__anonymous22_1);
+static inline void _X12_constructorFv_S13__anonymous22S13__anonymous22_autogen___1(struct __anonymous22 *_X4_dstS13__anonymous22_1, struct __anonymous22 _X4_srcS13__anonymous22_1);
+static inline void _X11_destructorFv_S13__anonymous22_autogen___1(struct __anonymous22 *_X4_dstS13__anonymous22_1);
+static inline struct __anonymous22 _X16_operator_assignFS13__anonymous22_S13__anonymous22S13__anonymous22_autogen___1(struct __anonymous22 *_X4_dstS13__anonymous22_1, struct __anonymous22 _X4_srcS13__anonymous22_1);
+static inline void _X12_constructorFv_S13__anonymous22i_autogen___1(struct __anonymous22 *_X4_dstS13__anonymous22_1, signed int _X1ii_1);
+static inline void _X12_constructorFv_S13__anonymous22_autogen___1(struct __anonymous22 *_X4_dstS13__anonymous22_1){
+    {
+        ((void)((*_X4_dstS13__anonymous22_1)._X1ii_1) /* ?{} */);
+    }
+}
+static inline void _X12_constructorFv_S13__anonymous22S13__anonymous22_autogen___1(struct __anonymous22 *_X4_dstS13__anonymous22_1, struct __anonymous22 _X4_srcS13__anonymous22_1){
+    {
+        ((void)((*_X4_dstS13__anonymous22_1)._X1ii_1=_X4_srcS13__anonymous22_1._X1ii_1) /* ?{} */);
+    }
+}
+static inline void _X11_destructorFv_S13__anonymous22_autogen___1(struct __anonymous22 *_X4_dstS13__anonymous22_1){
+    {
+        ((void)((*_X4_dstS13__anonymous22_1)._X1ii_1) /* ^?{} */);
+    }
+}
+static inline struct __anonymous22 _X16_operator_assignFS13__anonymous22_S13__anonymous22S13__anonymous22_autogen___1(struct __anonymous22 *_X4_dstS13__anonymous22_1, struct __anonymous22 _X4_srcS13__anonymous22_1){
+    struct __anonymous22 _X4_retS13__anonymous22_1;
+    {
+        ((void)((*_X4_dstS13__anonymous22_1)._X1ii_1=_X4_srcS13__anonymous22_1._X1ii_1));
+    }
+    {
+        ((void)_X12_constructorFv_S13__anonymous22S13__anonymous22_autogen___1((&_X4_retS13__anonymous22_1), (*_X4_dstS13__anonymous22_1)));
+    }
+    return _X4_retS13__anonymous22_1;
+}
+static inline void _X12_constructorFv_S13__anonymous22i_autogen___1(struct __anonymous22 *_X4_dstS13__anonymous22_1, signed int _X1ii_1){
+    {
+        ((void)((*_X4_dstS13__anonymous22_1)._X1ii_1=_X1ii_1) /* ?{} */);
+    }
+}
+static inline volatile const struct __anonymous22 _X3f37FS13__anonymous22___1();
+struct __anonymous23 {
+    signed int _X1ii_1;
+};
+static inline void _X12_constructorFv_S13__anonymous23_autogen___1(struct __anonymous23 *_X4_dstS13__anonymous23_1);
+static inline void _X12_constructorFv_S13__anonymous23S13__anonymous23_autogen___1(struct __anonymous23 *_X4_dstS13__anonymous23_1, struct __anonymous23 _X4_srcS13__anonymous23_1);
+static inline void _X11_destructorFv_S13__anonymous23_autogen___1(struct __anonymous23 *_X4_dstS13__anonymous23_1);
+static inline struct __anonymous23 _X16_operator_assignFS13__anonymous23_S13__anonymous23S13__anonymous23_autogen___1(struct __anonymous23 *_X4_dstS13__anonymous23_1, struct __anonymous23 _X4_srcS13__anonymous23_1);
+static inline void _X12_constructorFv_S13__anonymous23i_autogen___1(struct __anonymous23 *_X4_dstS13__anonymous23_1, signed int _X1ii_1);
+static inline void _X12_constructorFv_S13__anonymous23_autogen___1(struct __anonymous23 *_X4_dstS13__anonymous23_1){
+    {
+        ((void)((*_X4_dstS13__anonymous23_1)._X1ii_1) /* ?{} */);
+    }
+}
+static inline void _X12_constructorFv_S13__anonymous23S13__anonymous23_autogen___1(struct __anonymous23 *_X4_dstS13__anonymous23_1, struct __anonymous23 _X4_srcS13__anonymous23_1){
+    {
+        ((void)((*_X4_dstS13__anonymous23_1)._X1ii_1=_X4_srcS13__anonymous23_1._X1ii_1) /* ?{} */);
+    }
+}
+static inline void _X11_destructorFv_S13__anonymous23_autogen___1(struct __anonymous23 *_X4_dstS13__anonymous23_1){
+    {
+        ((void)((*_X4_dstS13__anonymous23_1)._X1ii_1) /* ^?{} */);
+    }
+}
+static inline struct __anonymous23 _X16_operator_assignFS13__anonymous23_S13__anonymous23S13__anonymous23_autogen___1(struct __anonymous23 *_X4_dstS13__anonymous23_1, struct __anonymous23 _X4_srcS13__anonymous23_1){
+    struct __anonymous23 _X4_retS13__anonymous23_1;
+    {
+        ((void)((*_X4_dstS13__anonymous23_1)._X1ii_1=_X4_srcS13__anonymous23_1._X1ii_1));
+    }
+    {
+        ((void)_X12_constructorFv_S13__anonymous23S13__anonymous23_autogen___1((&_X4_retS13__anonymous23_1), (*_X4_dstS13__anonymous23_1)));
+    }
+    return _X4_retS13__anonymous23_1;
+}
+static inline void _X12_constructorFv_S13__anonymous23i_autogen___1(struct __anonymous23 *_X4_dstS13__anonymous23_1, signed int _X1ii_1){
+    {
+        ((void)((*_X4_dstS13__anonymous23_1)._X1ii_1=_X1ii_1) /* ?{} */);
+    }
+}
+static inline volatile const struct __anonymous23 _X3f38FS13__anonymous23___1();
+static inline volatile const struct __anonymous21 _X3f38FS13__anonymous21___1();
 static inline volatile const signed short int _X3f41Fs___1();
 static inline volatile const signed short int _X3f42Fs___1();

tests/.expect/declarationSpecifier.x86.txt

-              r34b4268
+              r24d6572
+}
 volatile const struct __anonymous0 _X3x10KVS12__anonymous0_1;
+static volatile const struct __anonymous0 _X3x10KVS12__anonymous0_1;
 struct __anonymous1 {
     signed int _X1ii_1;
 …
+}
 volatile const struct __anonymous1 _X3x11KVS12__anonymous1_1;
+static volatile const struct __anonymous1 _X3x11KVS12__anonymous1_1;
 struct __anonymous2 {
     signed int _X1ii_1;
 …
+}
 volatile const struct __anonymous2 _X3x12KVS12__anonymous2_1;
+static volatile const struct __anonymous2 _X3x12KVS12__anonymous2_1;
 struct __anonymous3 {
     signed int _X1ii_1;
 …
+}
 static volatile const struct __anonymous6 _X3x16KVS12__anonymous6_1;
-struct __anonymous7 {
-    signed int _X1ii_1;
-};
-static inline void _X12_constructorFv_S12__anonymous7_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1);
-static inline void _X12_constructorFv_S12__anonymous7S12__anonymous7_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1, struct __anonymous7 _X4_srcS12__anonymous7_1);
-static inline void _X11_destructorFv_S12__anonymous7_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1);
-static inline struct __anonymous7 _X16_operator_assignFS12__anonymous7_S12__anonymous7S12__anonymous7_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1, struct __anonymous7 _X4_srcS12__anonymous7_1);
-static inline void _X12_constructorFv_S12__anonymous7i_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1, signed int _X1ii_1);
-static inline void _X12_constructorFv_S12__anonymous7_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1){
+    {
-        ((void)((*_X4_dstS12__anonymous7_1)._X1ii_1) /* ?{} */);
+    }
+}
-static inline void _X12_constructorFv_S12__anonymous7S12__anonymous7_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1, struct __anonymous7 _X4_srcS12__anonymous7_1){
+    {
-        ((void)((*_X4_dstS12__anonymous7_1)._X1ii_1=_X4_srcS12__anonymous7_1._X1ii_1) /* ?{} */);
+    }
+}
-static inline void _X11_destructorFv_S12__anonymous7_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1){
+    {
-        ((void)((*_X4_dstS12__anonymous7_1)._X1ii_1) /* ^?{} */);
+    }
+}
-static inline struct __anonymous7 _X16_operator_assignFS12__anonymous7_S12__anonymous7S12__anonymous7_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1, struct __anonymous7 _X4_srcS12__anonymous7_1){
-    struct __anonymous7 _X4_retS12__anonymous7_1;
+    {
-        ((void)((*_X4_dstS12__anonymous7_1)._X1ii_1=_X4_srcS12__anonymous7_1._X1ii_1));
+    }
+    {
-        ((void)_X12_constructorFv_S12__anonymous7S12__anonymous7_autogen___1((&_X4_retS12__anonymous7_1), (*_X4_dstS12__anonymous7_1)));
+    }
-    return _X4_retS12__anonymous7_1;
+}
-static inline void _X12_constructorFv_S12__anonymous7i_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1, signed int _X1ii_1){
+    {
-        ((void)((*_X4_dstS12__anonymous7_1)._X1ii_1=_X1ii_1) /* ?{} */);
+    }
+}
-static volatile const struct __anonymous7 _X3x17KVS12__anonymous7_1;
 volatile const signed short int _X3x20KVs_1;
 static volatile const signed short int _X3x21KVs_1;
 …
 static volatile const signed short int _X3x26KVs_1;
 static volatile const signed short int _X3x27KVs_1;
+struct __anonymous7 {
+    signed short int _X1is_1;
+};
+static inline void _X12_constructorFv_S12__anonymous7_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1);
+static inline void _X12_constructorFv_S12__anonymous7S12__anonymous7_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1, struct __anonymous7 _X4_srcS12__anonymous7_1);
+static inline void _X11_destructorFv_S12__anonymous7_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1);
+static inline struct __anonymous7 _X16_operator_assignFS12__anonymous7_S12__anonymous7S12__anonymous7_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1, struct __anonymous7 _X4_srcS12__anonymous7_1);
+static inline void _X12_constructorFv_S12__anonymous7s_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1, signed short int _X1is_1);
+static inline void _X12_constructorFv_S12__anonymous7_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1){
+    {
+        ((void)((*_X4_dstS12__anonymous7_1)._X1is_1) /* ?{} */);
+    }
+}
+static inline void _X12_constructorFv_S12__anonymous7S12__anonymous7_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1, struct __anonymous7 _X4_srcS12__anonymous7_1){
+    {
+        ((void)((*_X4_dstS12__anonymous7_1)._X1is_1=_X4_srcS12__anonymous7_1._X1is_1) /* ?{} */);
+    }
+}
+static inline void _X11_destructorFv_S12__anonymous7_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1){
+    {
+        ((void)((*_X4_dstS12__anonymous7_1)._X1is_1) /* ^?{} */);
+    }
+}
+static inline struct __anonymous7 _X16_operator_assignFS12__anonymous7_S12__anonymous7S12__anonymous7_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1, struct __anonymous7 _X4_srcS12__anonymous7_1){
+    struct __anonymous7 _X4_retS12__anonymous7_1;
+    {
+        ((void)((*_X4_dstS12__anonymous7_1)._X1is_1=_X4_srcS12__anonymous7_1._X1is_1));
+    }
+    {
+        ((void)_X12_constructorFv_S12__anonymous7S12__anonymous7_autogen___1((&_X4_retS12__anonymous7_1), (*_X4_dstS12__anonymous7_1)));
+    }
+    return _X4_retS12__anonymous7_1;
+}
+static inline void _X12_constructorFv_S12__anonymous7s_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1, signed short int _X1is_1){
+    {
+        ((void)((*_X4_dstS12__anonymous7_1)._X1is_1=_X1is_1) /* ?{} */);
+    }
+}
+static volatile const struct __anonymous7 _X3x29KVS12__anonymous7_1;
 struct __anonymous8 {
     signed short int _X1is_1;
 …
+}
 volatile const struct __anonymous8 _X3x29KVS12__anonymous8_1;
+static volatile const struct __anonymous8 _X3x30KVS12__anonymous8_1;
 struct __anonymous9 {
     signed short int _X1is_1;
 …
+}
 volatile const struct __anonymous9 _X3x30KVS12__anonymous9_1;
+static volatile const struct __anonymous9 _X3x31KVS12__anonymous9_1;
 struct __anonymous10 {
     signed short int _X1is_1;
 …
+}
 volatile const struct __anonymous10 _X3x31KVS13__anonymous10_1;
+static volatile const struct __anonymous10 _X3x32KVS13__anonymous10_1;
 struct __anonymous11 {
     signed short int _X1is_1;
 …
+}
 static volatile const struct __anonymous11 _X3x32KVS13__anonymous11_1;
+static volatile const struct __anonymous11 _X3x33KVS13__anonymous11_1;
 struct __anonymous12 {
     signed short int _X1is_1;
 …
+}
 static volatile const struct __anonymous12 _X3x33KVS13__anonymous12_1;
+static volatile const struct __anonymous12 _X3x34KVS13__anonymous12_1;
 struct __anonymous13 {
     signed short int _X1is_1;
 …
+}
+static volatile const struct __anonymous13 _X3x34KVS13__anonymous13_1;
+struct __anonymous14 {
+    signed short int _X1is_1;
+};
+static inline void _X12_constructorFv_S13__anonymous14_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1);
+static inline void _X12_constructorFv_S13__anonymous14S13__anonymous14_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1, struct __anonymous14 _X4_srcS13__anonymous14_1);
+static inline void _X11_destructorFv_S13__anonymous14_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1);
+static inline struct __anonymous14 _X16_operator_assignFS13__anonymous14_S13__anonymous14S13__anonymous14_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1, struct __anonymous14 _X4_srcS13__anonymous14_1);
+static inline void _X12_constructorFv_S13__anonymous14s_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1, signed short int _X1is_1);
+static inline void _X12_constructorFv_S13__anonymous14_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1){
+    {
+        ((void)((*_X4_dstS13__anonymous14_1)._X1is_1) /* ?{} */);
+    }
+}
+static inline void _X12_constructorFv_S13__anonymous14S13__anonymous14_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1, struct __anonymous14 _X4_srcS13__anonymous14_1){
+    {
+        ((void)((*_X4_dstS13__anonymous14_1)._X1is_1=_X4_srcS13__anonymous14_1._X1is_1) /* ?{} */);
+    }
+}
+static inline void _X11_destructorFv_S13__anonymous14_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1){
+    {
+        ((void)((*_X4_dstS13__anonymous14_1)._X1is_1) /* ^?{} */);
+    }
+}
+static inline struct __anonymous14 _X16_operator_assignFS13__anonymous14_S13__anonymous14S13__anonymous14_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1, struct __anonymous14 _X4_srcS13__anonymous14_1){
+    struct __anonymous14 _X4_retS13__anonymous14_1;
+    {
+        ((void)((*_X4_dstS13__anonymous14_1)._X1is_1=_X4_srcS13__anonymous14_1._X1is_1));
+    }
+    {
+        ((void)_X12_constructorFv_S13__anonymous14S13__anonymous14_autogen___1((&_X4_retS13__anonymous14_1), (*_X4_dstS13__anonymous14_1)));
+    }
+    return _X4_retS13__anonymous14_1;
+}
+static inline void _X12_constructorFv_S13__anonymous14s_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1, signed short int _X1is_1){
+    {
+        ((void)((*_X4_dstS13__anonymous14_1)._X1is_1=_X1is_1) /* ?{} */);
+    }
+}
+static volatile const struct __anonymous14 _X3x35KVS13__anonymous14_1;
+struct __anonymous15 {
+    signed short int _X1is_1;
+};
+static inline void _X12_constructorFv_S13__anonymous15_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1);
+static inline void _X12_constructorFv_S13__anonymous15S13__anonymous15_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1, struct __anonymous15 _X4_srcS13__anonymous15_1);
+static inline void _X11_destructorFv_S13__anonymous15_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1);
+static inline struct __anonymous15 _X16_operator_assignFS13__anonymous15_S13__anonymous15S13__anonymous15_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1, struct __anonymous15 _X4_srcS13__anonymous15_1);
+static inline void _X12_constructorFv_S13__anonymous15s_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1, signed short int _X1is_1);
+static inline void _X12_constructorFv_S13__anonymous15_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1){
+    {
+        ((void)((*_X4_dstS13__anonymous15_1)._X1is_1) /* ?{} */);
+    }
+}
+static inline void _X12_constructorFv_S13__anonymous15S13__anonymous15_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1, struct __anonymous15 _X4_srcS13__anonymous15_1){
+    {
+        ((void)((*_X4_dstS13__anonymous15_1)._X1is_1=_X4_srcS13__anonymous15_1._X1is_1) /* ?{} */);
+    }
+}
+static inline void _X11_destructorFv_S13__anonymous15_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1){
+    {
+        ((void)((*_X4_dstS13__anonymous15_1)._X1is_1) /* ^?{} */);
+    }
+}
+static inline struct __anonymous15 _X16_operator_assignFS13__anonymous15_S13__anonymous15S13__anonymous15_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1, struct __anonymous15 _X4_srcS13__anonymous15_1){
+    struct __anonymous15 _X4_retS13__anonymous15_1;
+    {
+        ((void)((*_X4_dstS13__anonymous15_1)._X1is_1=_X4_srcS13__anonymous15_1._X1is_1));
+    }
+    {
+        ((void)_X12_constructorFv_S13__anonymous15S13__anonymous15_autogen___1((&_X4_retS13__anonymous15_1), (*_X4_dstS13__anonymous15_1)));
+    }
+    return _X4_retS13__anonymous15_1;
+}
+static inline void _X12_constructorFv_S13__anonymous15s_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1, signed short int _X1is_1){
+    {
+        ((void)((*_X4_dstS13__anonymous15_1)._X1is_1=_X1is_1) /* ?{} */);
+    }
+}
+static volatile const struct __anonymous15 _X3x36KVS13__anonymous15_1;
+static volatile const struct __anonymous13 _X3x35KVS13__anonymous13_1;
 _Thread_local signed int _X3x37i_1;
 __thread signed int _X3x38i_1;
 …
 static inline volatile const signed short int _X3f27Fs___1();
 static inline volatile const signed short int _X3f28Fs___1();
+struct __anonymous14 {
+    signed int _X1ii_1;
+};
+static inline void _X12_constructorFv_S13__anonymous14_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1);
+static inline void _X12_constructorFv_S13__anonymous14S13__anonymous14_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1, struct __anonymous14 _X4_srcS13__anonymous14_1);
+static inline void _X11_destructorFv_S13__anonymous14_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1);
+static inline struct __anonymous14 _X16_operator_assignFS13__anonymous14_S13__anonymous14S13__anonymous14_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1, struct __anonymous14 _X4_srcS13__anonymous14_1);
+static inline void _X12_constructorFv_S13__anonymous14i_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1, signed int _X1ii_1);
+static inline void _X12_constructorFv_S13__anonymous14_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1){
+    {
+        ((void)((*_X4_dstS13__anonymous14_1)._X1ii_1) /* ?{} */);
+    }
+}
+static inline void _X12_constructorFv_S13__anonymous14S13__anonymous14_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1, struct __anonymous14 _X4_srcS13__anonymous14_1){
+    {
+        ((void)((*_X4_dstS13__anonymous14_1)._X1ii_1=_X4_srcS13__anonymous14_1._X1ii_1) /* ?{} */);
+    }
+}
+static inline void _X11_destructorFv_S13__anonymous14_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1){
+    {
+        ((void)((*_X4_dstS13__anonymous14_1)._X1ii_1) /* ^?{} */);
+    }
+}
+static inline struct __anonymous14 _X16_operator_assignFS13__anonymous14_S13__anonymous14S13__anonymous14_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1, struct __anonymous14 _X4_srcS13__anonymous14_1){
+    struct __anonymous14 _X4_retS13__anonymous14_1;
+    {
+        ((void)((*_X4_dstS13__anonymous14_1)._X1ii_1=_X4_srcS13__anonymous14_1._X1ii_1));
+    }
+    {
+        ((void)_X12_constructorFv_S13__anonymous14S13__anonymous14_autogen___1((&_X4_retS13__anonymous14_1), (*_X4_dstS13__anonymous14_1)));
+    }
+    return _X4_retS13__anonymous14_1;
+}
+static inline void _X12_constructorFv_S13__anonymous14i_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1, signed int _X1ii_1){
+    {
+        ((void)((*_X4_dstS13__anonymous14_1)._X1ii_1=_X1ii_1) /* ?{} */);
+    }
+}
+static inline volatile const struct __anonymous14 _X3f31FS13__anonymous14___1();
+struct __anonymous15 {
+    signed int _X1ii_1;
+};
+static inline void _X12_constructorFv_S13__anonymous15_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1);
+static inline void _X12_constructorFv_S13__anonymous15S13__anonymous15_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1, struct __anonymous15 _X4_srcS13__anonymous15_1);
+static inline void _X11_destructorFv_S13__anonymous15_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1);
+static inline struct __anonymous15 _X16_operator_assignFS13__anonymous15_S13__anonymous15S13__anonymous15_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1, struct __anonymous15 _X4_srcS13__anonymous15_1);
+static inline void _X12_constructorFv_S13__anonymous15i_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1, signed int _X1ii_1);
+static inline void _X12_constructorFv_S13__anonymous15_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1){
+    {
+        ((void)((*_X4_dstS13__anonymous15_1)._X1ii_1) /* ?{} */);
+    }
+}
+static inline void _X12_constructorFv_S13__anonymous15S13__anonymous15_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1, struct __anonymous15 _X4_srcS13__anonymous15_1){
+    {
+        ((void)((*_X4_dstS13__anonymous15_1)._X1ii_1=_X4_srcS13__anonymous15_1._X1ii_1) /* ?{} */);
+    }
+}
+static inline void _X11_destructorFv_S13__anonymous15_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1){
+    {
+        ((void)((*_X4_dstS13__anonymous15_1)._X1ii_1) /* ^?{} */);
+    }
+}
+static inline struct __anonymous15 _X16_operator_assignFS13__anonymous15_S13__anonymous15S13__anonymous15_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1, struct __anonymous15 _X4_srcS13__anonymous15_1){
+    struct __anonymous15 _X4_retS13__anonymous15_1;
+    {
+        ((void)((*_X4_dstS13__anonymous15_1)._X1ii_1=_X4_srcS13__anonymous15_1._X1ii_1));
+    }
+    {
+        ((void)_X12_constructorFv_S13__anonymous15S13__anonymous15_autogen___1((&_X4_retS13__anonymous15_1), (*_X4_dstS13__anonymous15_1)));
+    }
+    return _X4_retS13__anonymous15_1;
+}
+static inline void _X12_constructorFv_S13__anonymous15i_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1, signed int _X1ii_1){
+    {
+        ((void)((*_X4_dstS13__anonymous15_1)._X1ii_1=_X1ii_1) /* ?{} */);
+    }
+}
+static inline volatile const struct __anonymous15 _X3f32FS13__anonymous15___1();
 struct __anonymous16 {
     signed int _X1ii_1;
 …
+}
 static inline volatile const struct __anonymous16 _X3f31FS13__anonymous16___1();
+static inline volatile const struct __anonymous16 _X3f33FS13__anonymous16___1();
 struct __anonymous17 {
     signed int _X1ii_1;
 …
+}
 static inline volatile const struct __anonymous17 _X3f32FS13__anonymous17___1();
+static inline volatile const struct __anonymous17 _X3f34FS13__anonymous17___1();
 struct __anonymous18 {
     signed int _X1ii_1;
 …
+}
 static inline volatile const struct __anonymous18 _X3f33FS13__anonymous18___1();
+static inline volatile const struct __anonymous18 _X3f35FS13__anonymous18___1();
 struct __anonymous19 {
     signed int _X1ii_1;
 …
+}
 static inline volatile const struct __anonymous19 _X3f34FS13__anonymous19___1();
+static inline volatile const struct __anonymous19 _X3f36FS13__anonymous19___1();
 struct __anonymous20 {
     signed int _X1ii_1;
 …
+}
 static inline volatile const struct __anonymous20 _X3f35FS13__anonymous20___1();
+static inline volatile const struct __anonymous20 _X3f37FS13__anonymous20___1();
 struct __anonymous21 {
     signed int _X1ii_1;
 …
+}
+static inline volatile const struct __anonymous21 _X3f36FS13__anonymous21___1();
+struct __anonymous22 {
+    signed int _X1ii_1;
+};
+static inline void _X12_constructorFv_S13__anonymous22_autogen___1(struct __anonymous22 *_X4_dstS13__anonymous22_1);
+static inline void _X12_constructorFv_S13__anonymous22S13__anonymous22_autogen___1(struct __anonymous22 *_X4_dstS13__anonymous22_1, struct __anonymous22 _X4_srcS13__anonymous22_1);
+static inline void _X11_destructorFv_S13__anonymous22_autogen___1(struct __anonymous22 *_X4_dstS13__anonymous22_1);
+static inline struct __anonymous22 _X16_operator_assignFS13__anonymous22_S13__anonymous22S13__anonymous22_autogen___1(struct __anonymous22 *_X4_dstS13__anonymous22_1, struct __anonymous22 _X4_srcS13__anonymous22_1);
+static inline void _X12_constructorFv_S13__anonymous22i_autogen___1(struct __anonymous22 *_X4_dstS13__anonymous22_1, signed int _X1ii_1);
+static inline void _X12_constructorFv_S13__anonymous22_autogen___1(struct __anonymous22 *_X4_dstS13__anonymous22_1){
+    {
+        ((void)((*_X4_dstS13__anonymous22_1)._X1ii_1) /* ?{} */);
+    }
+}
+static inline void _X12_constructorFv_S13__anonymous22S13__anonymous22_autogen___1(struct __anonymous22 *_X4_dstS13__anonymous22_1, struct __anonymous22 _X4_srcS13__anonymous22_1){
+    {
+        ((void)((*_X4_dstS13__anonymous22_1)._X1ii_1=_X4_srcS13__anonymous22_1._X1ii_1) /* ?{} */);
+    }
+}
+static inline void _X11_destructorFv_S13__anonymous22_autogen___1(struct __anonymous22 *_X4_dstS13__anonymous22_1){
+    {
+        ((void)((*_X4_dstS13__anonymous22_1)._X1ii_1) /* ^?{} */);
+    }
+}
+static inline struct __anonymous22 _X16_operator_assignFS13__anonymous22_S13__anonymous22S13__anonymous22_autogen___1(struct __anonymous22 *_X4_dstS13__anonymous22_1, struct __anonymous22 _X4_srcS13__anonymous22_1){
+    struct __anonymous22 _X4_retS13__anonymous22_1;
+    {
+        ((void)((*_X4_dstS13__anonymous22_1)._X1ii_1=_X4_srcS13__anonymous22_1._X1ii_1));
+    }
+    {
+        ((void)_X12_constructorFv_S13__anonymous22S13__anonymous22_autogen___1((&_X4_retS13__anonymous22_1), (*_X4_dstS13__anonymous22_1)));
+    }
+    return _X4_retS13__anonymous22_1;
+}
+static inline void _X12_constructorFv_S13__anonymous22i_autogen___1(struct __anonymous22 *_X4_dstS13__anonymous22_1, signed int _X1ii_1){
+    {
+        ((void)((*_X4_dstS13__anonymous22_1)._X1ii_1=_X1ii_1) /* ?{} */);
+    }
+}
+static inline volatile const struct __anonymous22 _X3f37FS13__anonymous22___1();
+struct __anonymous23 {
+    signed int _X1ii_1;
+};
+static inline void _X12_constructorFv_S13__anonymous23_autogen___1(struct __anonymous23 *_X4_dstS13__anonymous23_1);
+static inline void _X12_constructorFv_S13__anonymous23S13__anonymous23_autogen___1(struct __anonymous23 *_X4_dstS13__anonymous23_1, struct __anonymous23 _X4_srcS13__anonymous23_1);
+static inline void _X11_destructorFv_S13__anonymous23_autogen___1(struct __anonymous23 *_X4_dstS13__anonymous23_1);
+static inline struct __anonymous23 _X16_operator_assignFS13__anonymous23_S13__anonymous23S13__anonymous23_autogen___1(struct __anonymous23 *_X4_dstS13__anonymous23_1, struct __anonymous23 _X4_srcS13__anonymous23_1);
+static inline void _X12_constructorFv_S13__anonymous23i_autogen___1(struct __anonymous23 *_X4_dstS13__anonymous23_1, signed int _X1ii_1);
+static inline void _X12_constructorFv_S13__anonymous23_autogen___1(struct __anonymous23 *_X4_dstS13__anonymous23_1){
+    {
+        ((void)((*_X4_dstS13__anonymous23_1)._X1ii_1) /* ?{} */);
+    }
+}
+static inline void _X12_constructorFv_S13__anonymous23S13__anonymous23_autogen___1(struct __anonymous23 *_X4_dstS13__anonymous23_1, struct __anonymous23 _X4_srcS13__anonymous23_1){
+    {
+        ((void)((*_X4_dstS13__anonymous23_1)._X1ii_1=_X4_srcS13__anonymous23_1._X1ii_1) /* ?{} */);
+    }
+}
+static inline void _X11_destructorFv_S13__anonymous23_autogen___1(struct __anonymous23 *_X4_dstS13__anonymous23_1){
+    {
+        ((void)((*_X4_dstS13__anonymous23_1)._X1ii_1) /* ^?{} */);
+    }
+}
+static inline struct __anonymous23 _X16_operator_assignFS13__anonymous23_S13__anonymous23S13__anonymous23_autogen___1(struct __anonymous23 *_X4_dstS13__anonymous23_1, struct __anonymous23 _X4_srcS13__anonymous23_1){
+    struct __anonymous23 _X4_retS13__anonymous23_1;
+    {
+        ((void)((*_X4_dstS13__anonymous23_1)._X1ii_1=_X4_srcS13__anonymous23_1._X1ii_1));
+    }
+    {
+        ((void)_X12_constructorFv_S13__anonymous23S13__anonymous23_autogen___1((&_X4_retS13__anonymous23_1), (*_X4_dstS13__anonymous23_1)));
+    }
+    return _X4_retS13__anonymous23_1;
+}
+static inline void _X12_constructorFv_S13__anonymous23i_autogen___1(struct __anonymous23 *_X4_dstS13__anonymous23_1, signed int _X1ii_1){
+    {
+        ((void)((*_X4_dstS13__anonymous23_1)._X1ii_1=_X1ii_1) /* ?{} */);
+    }
+}
+static inline volatile const struct __anonymous23 _X3f38FS13__anonymous23___1();
+static inline volatile const struct __anonymous21 _X3f38FS13__anonymous21___1();
 static inline volatile const signed short int _X3f41Fs___1();
 static inline volatile const signed short int _X3f42Fs___1();

tests/.expect/forall.txt

-              r34b4268
+              r24d6572
+forall.cfa:244:25: warning: Compiled
+f
+f
+g
+f
+f
+g
+fT
+fT
+fT
+fTU
+fTU
+fTU
+2
+1
+, 2
+@ 0 2 0 4 6.4 6.4 6.4 6.4+3.i 4
+. 3.
+3

tests/.expect/nested_function.x64.txt

r34b4268	r24d6572
1		total 80
	1	total 145

tests/.expect/nested_function.x86.txt

r34b4268	r24d6572
1		total 55
	1	total 245

tests/Makefile.am

-              r34b4268
+              r24d6572
 ## Created On       : Sun May 31 09:08:15 2015
 ## Last Modified By : Peter A. Buhr
 ## Last Modified On : Sat Jun  5 14:49:25 2021
 ## Update Count     : 92
+## Last Modified On : Sun May 28 08:15:43 2023
+## Update Count     : 196
 ###############################################################################
 …
 DEFAULT_INCLUDES = -I${abs_srcdir}
+debug=yes
+installed=no
+archiveerrors=
+DEBUG_FLAGS=-debug -g -O0
+quick_test=avl_test operators numericConstants expression enum array typeof cast raii/dtor-early-exit raii/init_once attributes meta/dumpable
+concurrent=
+timeouts=
+debug ?= yes
+installed ?= no
+ARCH = ${if ${arch},"--arch=${arch}"}
+arch_support = "x86/x64/arm"
+TIMEOUT = ${if ${timeout},"--timeout=${timeout}"}
+GLOBAL_TIMEOUT = ${if ${global-timeout},"--global-timeout=${global-timeout}"}
+ARCHIVE_ERRORS = ${if ${archive-errors},"--archive-errors=${archive-errors}"}
+DEBUG_FLAGS = -debug -g -O0
+quick_test = avl_test operators numericConstants expression enum array typeof cast raii/dtor-early-exit raii/init_once attributes meta/dumpable
 TEST_PY = python3 ${builddir}/test.py
 …
 # applies to both programs
 # since automake doesn't have support for CFA we have to
 AM_CFLAGS = $(if $(test), 2> $(test), ) \
         -fdebug-prefix-map=$(abspath ${abs_srcdir})= \
+AM_CFLAGS = ${if ${test}, 2> ${test}, } \
+        -fdebug-prefix-map=${abspath ${abs_srcdir}}= \
         -fdebug-prefix-map=/tmp= \
         -fno-diagnostics-show-caret \
 …
 # get the desired cfa to test
 TARGET_CFA = $(if $(filter $(installed),yes), @CFACC_INSTALL@, @CFACC@)
+TARGET_CFA = ${if ${filter ${installed},yes}, @CFACC_INSTALL@, @CFACC@}
 # adjust CC to current flags
 CC = LC_ALL=C $(if $(DISTCC_CFA_PATH),distcc $(DISTCC_CFA_PATH) ${ARCH_FLAGS} ,$(TARGET_CFA) ${DEBUG_FLAGS} ${ARCH_FLAGS})
 CFACC = $(CC)
+CC = LC_ALL=C ${if ${DISTCC_CFA_PATH},distcc ${DISTCC_CFA_PATH} ${ARCH_FLAGS} ,${TARGET_CFA} ${DEBUG_FLAGS} ${ARCH_FLAGS}}
+CFACC = ${CC}
 # get local binary for depedencies
 …
 # adjusted CC but without the actual distcc call
 CFACCLOCAL = $(if $(DISTCC_CFA_PATH),$(DISTCC_CFA_PATH) ${ARCH_FLAGS} ,$(TARGET_CFA) ${DEBUG_FLAGS} ${ARCH_FLAGS})
 CFACCLINK = $(CFACCLOCAL) -quiet $(if $(test), 2> $(test), ) $($(shell echo "${@}_FLAGSLD" | sed 's/-\|\//_/g'))
 PRETTY_PATH=mkdir -p $(dir $(abspath ${@})) && cd ${srcdir} &&
 .PHONY: list .validate .test_makeflags
 .INTERMEDIATE: .validate .validate.cfa .test_makeflags
+CFACCLOCAL = ${if ${DISTCC_CFA_PATH},${DISTCC_CFA_PATH} ${ARCH_FLAGS} ,${TARGET_CFA} ${DEBUG_FLAGS} ${ARCH_FLAGS}}
+CFACCLINK = ${CFACCLOCAL} -quiet ${if ${test}, 2> ${test}, } ${${shell echo "${@}_FLAGSLD" | sed 's/-\|\//_/g'}}
+PRETTY_PATH = mkdir -p ${dir ${abspath ${@}}} && cd ${srcdir} &&
+.PHONY : concurrency list .validate .test_makeflags
+.INTERMEDIATE : .validate .validate.cfa .test_makeflags
 EXTRA_PROGRAMS = avl_test linkonce linking/mangling/anon .dummy_hack # build but do not install
 EXTRA_DIST = test.py \
 …
         avltree/avl-private.h \
         avltree/avl.h \
-        concurrent/clib_tls.c \
-        concurrent/clib.c \
         configs/.in/parseconfig-all.txt \
         configs/.in/parseconfig-errors.txt \
 …
         io/.in/many_read.data \
         meta/fork+exec.hfa \
+        unified_locking/mutex_test.hfa
+        concurrency/clib_tls.c \
+        concurrency/clib.c \
+        concurrency/unified_locking/mutex_test.hfa \
+        concurrency/channels/parallel_harness.hfa
 dist-hook:
 …
         for file in `${TEST_PY} --list-dist`; do \
                 if test -f ${srcdir}/$${file}; then \
                         $(MKDIR_P) $$(dirname ${distdir}/$${file}); \
+                        ${MKDIR_P} $$(dirname ${distdir}/$${file}); \
                         cp -df ${srcdir}/$${file} ${distdir}/$${file}; \
                 fi; \
 …
 #----------------------------------------------------------------------------------------------------------------
+all-local :
+        @+${TEST_PY} --debug=${debug} --install=${installed} --archive-errors=${archiveerrors} ${concurrent} ${timeouts} ${quick_test}
+all-tests :
+        @+${TEST_PY} --debug=${debug} --install=${installed} --archive-errors=${archiveerrors} ${concurrent} ${timeouts} --all # '@' => do not echo command (SILENT), '+' => allows recursive make from within python program
+# '@' => do not echo command (SILENT), '+' => allows recursive make from within python program
+all-local : # This name is important to automake and implies the default build target.
+        @+${TEST_PY} --debug=${debug} --install=${installed} --invariant ${ARCHIVE_ERRORS} ${TIMEOUT} ${GLOBAL_TIMEOUT} ${ARCH} --all
+tests : all-local # synonym
+install : all-local  # synonym, PAB only
+quick :
+        @+${TEST_PY} --debug=${debug} --install=${installed} ${ARCHIVE_ERRORS} ${ARCH} ${quick_test}
+concurrency :
+        @+${TEST_PY} --debug=${debug} --install=${installed} ${ARCHIVE_ERRORS} ${TIMEOUT} ${GLOBAL_TIMEOUT} ${ARCH} -Iconcurrency
+list :
+        @+${TEST_PY} --list
+help :
+        @echo "user targets:"
+        @echo "    Run the complete test suite."
+        @echo "    $$ make (null) / tests [debug=yes/no] [installed=yes/no] [archive-errors=dump-dir] [timeout=seconds] [global-timeout=seconds] [arch=${arch_support}]"
+        @echo ""
+        @echo "    Run the short (quick) test suite."
+        @echo "    $$ make quick [debug=yes/no] [installed=yes/no] [archive-errors=dump-dir] [arch=${arch_support}]"
+        @echo ""
+        @echo "    Run the concurrency test suite."
+        @echo "    $$ make concurrency [debug=yes/no] [installed=yes/no] [archive-errors=dump-dir] [timeout=seconds] [global-timeout=seconds] [arch=${arch_support}]"
+        @echo ""
+        @echo "    List all tests in the test suite."
+        @echo "    $$ make list"
 mostlyclean-local :
 …
         find ${builddir} -path '*.Po' -delete
-list :
-        @+${TEST_PY} --list ${concurrent}
 .test_makeflags:
         @echo "${MAKEFLAGS}"
 .validate: .validate.cfa
         $(CFACOMPILE) .validate.cfa -fsyntax-only -Wall -Wextra -Werror
+        ${CFACOMPILE} .validate.cfa -fsyntax-only -Wall -Wextra -Werror
 .validate.cfa:
 …
         @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 "${@}_FLAGSCFA" | sed 's/-\|\//_/g'))
+CFACOMPILETEST=${PRETTY_PATH} ${CFACOMPILE} ${shell realpath --relative-to=${srcdir} ${<}} ${${shell echo "${@}_FLAGSCFA" | sed 's/-\|\//_/g'}}
 #----------------------------------------------------------------------------------------------------------------
 …
 # split into two steps to support compiling remotely using distcc
 # don't use distcc to do the linking because distcc doesn't do linking
 % : %.cfa $(CFACCBIN)
         $(CFACOMPILETEST) -c -o $(abspath ${@}).o -DIN_DIR="$(abspath $(dir ${<}))/.in/"
         $(CFACCLINK) ${@}.o -o $(abspath ${@})
         rm $(abspath ${@}).o
+% : %.cfa ${CFACCBIN}
+        ${CFACOMPILETEST} -c -o ${abspath ${@}}.o -DIN_DIR="${abspath ${dir ${<}}}/.in/"
+        ${CFACCLINK} ${@}.o -o ${abspath ${@}}
+        rm ${abspath ${@}}.o
 # implicit rule for c++ test
 # convient for testing the testsuite itself but not actuall used
 % : %.cpp
         $(PRETTY_PATH) $(CXXCOMPILE) $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
+        ${PRETTY_PATH} ${CXXCOMPILE} ${shell realpath --relative-to=${srcdir} ${<}} -o ${abspath ${@}}
 #------------------------------------------------------------------------------
 …
 # Generated code
 GENERATED_CODE = declarationSpecifier gccExtensions extension attributes functions KRfunctions
 $(GENERATED_CODE): % : %.cfa $(CFACCBIN)
         $(CFACOMPILETEST) -CFA -XCFA -p -c -fsyntax-only -o $(abspath ${@})
+${GENERATED_CODE} : % : %.cfa ${CFACCBIN}
+        ${CFACOMPILETEST} -CFA -XCFA -p -c -fsyntax-only -o ${abspath ${@}}
 #------------------------------------------------------------------------------
 …
 #------------------------------------------------------------------------------
 # tests that just validate syntax and compiler output should be compared to stderr
 CFACOMPILE_SYNTAX = $(CFACOMPILETEST) -Wno-unused-variable -Wno-unused-label -c -fsyntax-only -o $(abspath ${@})
 SYNTAX_ONLY_CODE = expression typedefRedef variableDeclarator switch numericConstants identFuncDeclarator forall \
         init1 limits nested-types cast labelledExit array quasiKeyword include/stdincludes include/includes builtins/sync warnings/self-assignment
 $(SYNTAX_ONLY_CODE): % : %.cfa $(CFACCBIN)
         $(CFACOMPILE_SYNTAX)
         $(if $(test), cp $(test) $(abspath ${@}), )
+CFACOMPILE_SYNTAX = ${CFACOMPILETEST} -Wno-unused-variable -Wno-unused-label -c -fsyntax-only -o ${abspath ${@}}
+SYNTAX_ONLY_CODE = expression typedefRedef variableDeclarator switch numericConstants identFuncDeclarator \
+        init1 limits nested-types cast labelledExit array quasiKeyword include/stdincludes include/includes builtins/sync warnings/self-assignment concurrency/waitfor/parse
+${SYNTAX_ONLY_CODE} : % : %.cfa ${CFACCBIN}
+        ${CFACOMPILE_SYNTAX}
+        ${if ${test}, cp ${test} ${abspath ${@}}, }
 # expected failures
 # use custom target since they require a custom define *and* have a name that doesn't match the file
+alloc-ERROR : alloc.cfa $(CFACCBIN)
+        $(CFACOMPILE_SYNTAX) -DERR1
+        -cp $(test) $(abspath ${@})
+init1-ERROR : init1.cfa $(CFACCBIN)
+        $(CFACOMPILE_SYNTAX) -DERR1
+        -cp $(test) $(abspath ${@})
+typedefRedef-ERR1 : typedefRedef.cfa $(CFACCBIN)
+        $(CFACOMPILE_SYNTAX) -DERR1
+        -cp $(test) $(abspath ${@})
+nested-types-ERR1 : nested-types.cfa $(CFACCBIN)
+        $(CFACOMPILE_SYNTAX) -DERR1
+        -cp $(test) $(abspath ${@})
+nested-types-ERR2 : nested-types.cfa $(CFACCBIN)
+        $(CFACOMPILE_SYNTAX) -DERR2
+        -cp $(test) $(abspath ${@})
+raii/memberCtors-ERR1 : raii/memberCtors.cfa $(CFACCBIN)
+        $(CFACOMPILE_SYNTAX) -DERR1
+        -cp $(test) $(abspath ${@})
+raii/ctor-autogen-ERR1 : raii/ctor-autogen.cfa $(CFACCBIN)
+        $(CFACOMPILE_SYNTAX) -DERR1
+        -cp $(test) $(abspath ${@})
+raii/dtor-early-exit-ERR1 : raii/dtor-early-exit.cfa $(CFACCBIN)
+        $(CFACOMPILE_SYNTAX) -DERR1
+        -cp $(test) $(abspath ${@})
+raii/dtor-early-exit-ERR2 : raii/dtor-early-exit.cfa $(CFACCBIN)
+        $(CFACOMPILE_SYNTAX) -DERR2
+        -cp $(test) $(abspath ${@})
+array-ERR1 : array.cfa ${CFACCBIN}
+        ${CFACOMPILE_SYNTAX} -DERR1
+        -cp ${test} ${abspath ${@}}
+array-ERR2 : array.cfa ${CFACCBIN}
+        ${CFACOMPILE_SYNTAX} -DERR2
+        -cp ${test} ${abspath ${@}}
+array-ERR3 : array.cfa ${CFACCBIN}
+        ${CFACOMPILE_SYNTAX} -DERR3
+        -cp ${test} ${abspath ${@}}
+alloc-ERROR : alloc.cfa ${CFACCBIN}
+        ${CFACOMPILE_SYNTAX} -DERR1
+        -cp ${test} ${abspath ${@}}
+init1-ERROR : init1.cfa ${CFACCBIN}
+        ${CFACOMPILE_SYNTAX} -DERR1
+        -cp ${test} ${abspath ${@}}
+typedefRedef-ERR1 : typedefRedef.cfa ${CFACCBIN}
+        ${CFACOMPILE_SYNTAX} -DERR1
+        -cp ${test} ${abspath ${@}}
+nested-types-ERR1 : nested-types.cfa ${CFACCBIN}
+        ${CFACOMPILE_SYNTAX} -DERR1
+        -cp ${test} ${abspath ${@}}
+nested-types-ERR2 : nested-types.cfa ${CFACCBIN}
+        ${CFACOMPILE_SYNTAX} -DERR2
+        -cp ${test} ${abspath ${@}}
+raii/memberCtors-ERR1 : raii/memberCtors.cfa ${CFACCBIN}
+        ${CFACOMPILE_SYNTAX} -DERR1
+        -cp ${test} ${abspath ${@}}
+raii/ctor-autogen-ERR1 : raii/ctor-autogen.cfa ${CFACCBIN}
+        ${CFACOMPILE_SYNTAX} -DERR1
+        -cp ${test} ${abspath ${@}}
+raii/dtor-early-exit-ERR1 : raii/dtor-early-exit.cfa ${CFACCBIN}
+        ${CFACOMPILE_SYNTAX} -DERR1
+        -cp ${test} ${abspath ${@}}
+raii/dtor-early-exit-ERR2 : raii/dtor-early-exit.cfa ${CFACCBIN}
+        ${CFACOMPILE_SYNTAX} -DERR2
+        -cp ${test} ${abspath ${@}}
 # Exception Tests
 # Test with libcfathread; it changes how storage works.
 exceptions/%-threads : exceptions/%.cfa $(CFACCBIN)
         $(CFACOMPILETEST) -include exceptions/with-threads.hfa -c -o $(abspath ${@}).o
         $(CFACCLOCAL) $($(shell echo "${@}_FLAGSLD" | sed 's/-\|\//_/g')) $(abspath ${@}).o -o $(abspath ${@})
+exceptions/%-threads : exceptions/%.cfa ${CFACCBIN}
+        ${CFACOMPILETEST} -include exceptions/with-threads.hfa -c -o ${abspath ${@}}.o
+        ${CFACCLOCAL} ${${shell echo "${@}_FLAGSLD" | sed 's/-\|\//_/g'}} ${abspath ${@}}.o -o ${abspath ${@}}
 # Linking tests
 # Meta tests to make sure we see linking errors (can't compile with -O2 since it may multiply number of calls)
 linking/linkerror : linking/linkerror.cfa $(CFACCBIN)
         $(CFACOMPILETEST) -O0 -c -o $(abspath ${@}).o
         $(CFACCLINK)  -O0 ${@}.o -o $(abspath ${@})
         rm $(abspath ${@}).o
+linking/linkerror : linking/linkerror.cfa ${CFACCBIN}
+        ${CFACOMPILETEST} -O0 -c -o ${abspath ${@}}.o
+        ${CFACCLINK}  -O0 ${@}.o -o ${abspath ${@}}
+        rm ${abspath ${@}}.o
 #------------------------------------------------------------------------------

tests/PRNG.cfa

-              r34b4268
+              r24d6572
+//                               -*- Mode: C -*-
+//
+//
 // Cforall Version 1.0.0 Copyright (C) 2021 University of Waterloo
+//
+// PRNG.c --
+//
+//
+// PRNG.c -- high-perforamnce pseudo-random numbers
+//
+// The contents of this file are covered under the licence agreement in the
+// file "LICENCE" distributed with Cforall.
+//
 // Author           : Peter A. Buhr
 // Created On       : Wed Dec 29 09:38:12 2021
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Tue Nov 22 22:51:12 2022
 // Update Count     : 381
+// Last Modified On : Thu May 25 15:39:52 2023
+// Update Count     : 422
 //
 …
 #include <stdlib.hfa>                                                                   // PRNG
 #include <clock.hfa>
-#include <thread.hfa>
 #include <limits.hfa>                                                                   // MAX
 #include <math.hfa>                                                                             // sqrt
 #include <malloc.h>                                                                             // malloc_stats
 #include <locale.h>                                                                             // setlocale
+#include <thread.hfa>
 #include <mutex_stmt.hfa>
+#ifdef __x86_64__                                                                               // 64-bit architecture
+#define xstr(s) str(s)
+#define str(s) #s
+#if defined( __x86_64__ ) || defined( __aarch64__ )             // 64-bit architecture
 #define PRNG PRNG64
 #else                                                                                                   // 32-bit architecture
 #define PRNG PRNG32
 #endif // __x86_64__
+//#define TIME
 #ifdef TIME                                                                                             // use -O2 -nodebug
 …
 #endif // TIME
 void avgstd( unsigned int buckets[] ) {
         unsigned int min = MAX, max = 0;
+static void avgstd( size_t trials, size_t buckets[] ) {
+        size_t min = MAX, max = 0;
         double sum = 0.0, diff;
         for ( i; BUCKETS ) {
 …
         } // for
         double std = sqrt( sum / BUCKETS );
         mutex( sout ) sout | "trials"  | TRIALS | "buckets" | BUCKETS
+        mutex( sout ) sout | "trials"  | trials | "buckets" | BUCKETS
                 | "min" | min | "max" | max
                 | "avg" | wd(0,1, avg) | "std" | wd(0,1, std) | "rstd" | wd(0,1, (avg == 0 ? 0.0 : std / avg * 100)) | "%";
 …
 unsigned int seed = 1009;
+size_t seed = 1009;
 thread T1 {};
 void main( T1 & ) {
         unsigned int * buckets = calloc( BUCKETS );                     // too big for task stack
         for ( TRIALS / 100 ) {
+        size_t * buckets = calloc( BUCKETS );                           // too big for task stack
+        for ( TRIALS / 50 ) {
                 buckets[rand() % BUCKETS] += 1;                                 // concurrent
         } // for
         avgstd( buckets );
+        avgstd( TRIALS / 50, buckets );
         free( buckets );
 } // main
 …
         PRNG prng;
         if ( seed != 0 ) set_seed( prng, seed );
         unsigned int * buckets = calloc( BUCKETS );                     // too big for task stack
+        size_t * buckets = calloc( BUCKETS );                           // too big for task stack
         for ( TRIALS ) {
                 buckets[prng( prng ) % BUCKETS] += 1;                   // concurrent
         } // for
         avgstd( buckets );
+        avgstd( TRIALS, buckets );
         free( buckets );
 } // main
 …
 thread T3 {};
 void main( T3 & th ) {
         unsigned int * buckets = calloc( BUCKETS );                     // too big for task stack
         for ( TRIALS ) {
+        size_t * buckets = calloc( BUCKETS );                           // too big for task stack
+        for ( TRIALS / 5 ) {
                 buckets[prng() % BUCKETS] += 1;                                 // concurrent
         } // for
         avgstd( buckets );
+        avgstd( TRIALS / 5, buckets );
         free( buckets );
 } // main
 …
 thread T4 {};
 void main( T4 & th ) {
         unsigned int * buckets = calloc( BUCKETS );                     // too big for task stack
+        size_t * buckets = calloc( BUCKETS );                           // too big for task stack
         for ( TRIALS ) {
                 buckets[prng( th ) % BUCKETS] += 1;     // concurrent
         } // for
         avgstd( buckets );
+                buckets[prng( th ) % BUCKETS] += 1;                             // concurrent
+        } // for
+        avgstd( TRIALS, buckets );
         free( buckets );
 } // main
 …
 static void dummy( thread$ & th ) __attribute__(( noinline ));
 static void dummy( thread$ & th ) {
         unsigned int * buckets = (unsigned int *)calloc( BUCKETS, sizeof(unsigned int) ); // too big for task stack
         for ( unsigned int i = 0; i < TRIALS; i += 1 ) {
+        size_t * buckets = (size_t *)calloc( BUCKETS, sizeof(size_t) ); // too big for task stack
+        for ( size_t i = 0; i < TRIALS; i += 1 ) {
                 buckets[prng( th ) % BUCKETS] += 1;                             // sequential
         } // for
         avgstd( buckets );
+        avgstd( TRIALS, buckets );
         free( buckets );
 } // dummy
 int main() {
+        // causes leaked storage message
+//      setlocale( LC_NUMERIC, getenv( "LANG" ) );                      // print digit separator
+        // setlocale( LC_NUMERIC, getenv( "LANG" ) );           // causes leaked storage message
+        // only works on the current pthread thread
+        // locale_t loc = newlocale( LC_NUMERIC_MASK, getenv( "LANG" ), (locale_t)0p );
+        // if ( loc == (locale_t)0p ) abort( "newlocale" );
+        // uselocale( loc );
         enum { TASKS = 4 };
         Time start;
 #ifdef TIME                                                                                             // too slow for test and generates non-repeatable results
 #if 1
+        unsigned int rseed;
+        sout | "glib rand" | nl | nl;
+        size_t rseed;
         if ( seed != 0 ) rseed = seed;
         else rseed = rdtscl();
 …
         sout | sepDisable;
         sout | wd(13, "rand()" ) | wd(10, "rand(5)") | wd(13, "rand(0,5)" );
         for ( 20 ) {
                 sout | wd(13, rand()) | nonl;
                 sout | wd(10, rand() % 5) | nonl;
                 sout | wd(13, rand() % (5 - 0 + 1) + 0);
+        sout | nl | wd(26, "rand()" ) | wd(12, "rand(5)") | wd(12, "rand(0,5)" );
+        for ( 20 ) {
+                sout | wd(26, rand()) | nonl;
+                sout | wd(12, rand() % 5) | nonl;
+                sout | wd(12, rand() % (5 - 0 + 1) + 0);
         } // for
         sout | sepEnable;
 …
         STARTTIME;
+        {
                 unsigned int * buckets = calloc( BUCKETS );             // too big for task stack
                 for ( i; TRIALS / 10 ) {
+                size_t * buckets = calloc( BUCKETS );                   // too big for task stack
+                for ( i; TRIALS / 5 ) {
                         buckets[rand() % BUCKETS] += 1;                         // sequential
                 } // for
                 avgstd( buckets );
+                avgstd( TRIALS / 5, buckets );
                 free( buckets );
+        }
         ENDTIME( " x 10 " );
+        ENDTIME( " x 5 " );
         sout | nl | "Concurrent";
 …
                 } // wait for threads to complete
+        }
         ENDTIME( " x 100 " );
+        ENDTIME( " x 50 " );
 #endif // 0
 #endif // TIME
+        sout | nl | "CFA " xstr(PRNG_NAME);
 #if 1
         PRNG prng;
 …
         sout | sepDisable;
         sout | nl | wd(13, "PRNG()" ) | wd(10, "PRNG(5)") | wd(13, "PRNG(0,5)" );
         for ( 20 ) {
                 sout | wd(13, prng( prng )) | nonl;                             // cascading => side-effect functions called in arbitary order
                 sout | wd(10, prng( prng, 5 )) | nonl;
                 sout | wd(13, prng( prng, 0, 5 ));
+        sout | nl | wd(26, "PRNG()" ) | wd(12, "PRNG(5)") | wd(12, "PRNG(0,5)" );
+        for ( 20 ) {
+                sout | wd(26, prng( prng )) | nonl;                             // cascading => side-effect functions called in arbitary order
+                sout | wd(12, prng( prng, 5 )) | nonl;
+                sout | wd(12, prng( prng, 0, 5 ));
         } // for
         sout | sepEnable;
 …
         STARTTIME;
+        {
                 unsigned int * buckets = calloc( BUCKETS );             // too big for task stack
+                size_t * buckets = calloc( BUCKETS );                   // too big for task stack
                 for ( TRIALS ) {
                         buckets[prng( prng ) % BUCKETS] += 1;           // sequential
                 } // for
                 avgstd( buckets );
+                avgstd( TRIALS, buckets );
                 free( buckets );
+        }
 …
         sout | sepDisable;
         sout | nl | wd(13, "prng()" ) | wd(10, "prng(5)") | wd(13, "prng(0,5)" );
         for ( 20 ) {
                 sout | wd(13, prng()) | nonl;                                   // cascading => side-effect functions called in arbitary order
                 sout | wd(10, prng( 5 )) | nonl;
                 sout | wd(13, prng( 0, 5 ));
+        sout | nl | wd(26, "prng()" ) | wd(12, "prng(5)") | wd(12, "prng(0,5)" );
+        for ( 20 ) {
+                sout | wd(26, prng()) | nonl;                                   // cascading => side-effect functions called in arbitary order
+                sout | wd(12, prng( 5 )) | nonl;
+                sout | wd(12, prng( 0, 5 ));
         } // for
         sout | sepEnable;
 …
         STARTTIME;
+        {
                 unsigned int * buckets = calloc( BUCKETS );             // too big for task stack
                 for ( TRIALS ) {
+                size_t * buckets = calloc( BUCKETS );                   // too big for task stack
+                for ( TRIALS / 5 ) {
                         buckets[prng() % BUCKETS] += 1;
                 } // for
                 avgstd( buckets );
+                avgstd( TRIALS / 5, buckets );
                 free( buckets );
+        }
         ENDTIME();
+        ENDTIME( " x 5 " );
         sout | nl | "Concurrent";
 …
                 } // wait for threads to complete
+        }
         ENDTIME();
+        ENDTIME( " x 5 " );
 #endif // 0
 #if 1
 …
         sout | sepDisable;
         sout | nl | wd(13, "prng(t)" ) | wd(10, "prng(t,5)") | wd(13, "prng(t,0,5)" );
         for ( 20 ) {
                 sout | wd(13, prng( th )) | nonl;                               // cascading => side-effect functions called in arbitary order
                 sout | wd(10, prng( th, 5 )) | nonl;
                 sout | wd(13, prng( th, 0, 5 ));
+        sout | nl | wd(26, "prng(t)" ) | wd(12, "prng(t,5)") | wd(12, "prng(t,0,5)" );
+        for ( 20 ) {
+                sout | wd(26, prng( th )) | nonl;                               // cascading => side-effect functions called in arbitary order
+                sout | wd(12, prng( th, 5 )) | nonl;
+                sout | wd(12, prng( th, 0, 5 ));
         } // for
         sout | sepEnable;
 …
 #endif // 0
 //      malloc_stats();
+        // freelocale( loc );
 } // main

tests/array.cfa

-              r34b4268
+              r24d6572
 //
+int a1[0];
 //int a2[*];
 //double a4[3.0];
+// Tests syntax.  Comments explain semantics.  Test does not show semantics.
+// Mostly illustrates facts about C (with which CFA is being tested to agree).
+// Is a test oracle under `gcc -x c`.
+int m1[0][3];
+//int m2[*][*];
+int m4[3][3];
+#ifdef ERR1
+#define E1(...) __VA_ARGS__
+#else
+#define E1(...)
+#endif
+typedef int T;
+#ifdef ERR2
+#define E2(...) __VA_ARGS__
+#else
+#define E2(...)
+#endif
+int fred() {
+//      int a1[];
+//      int a2[*];
+        int a4[3];
+        int T[3];
+}
+#ifdef ERR3
+#define E3(...) __VA_ARGS__
+#else
+#define E3(...)
+#endif
+int mary( int T[3],
+                  int p1[const 3],
+                  int p2[static 3],
+                  int p3[static const 3]
+        ) {
+}
+    int a1[0];
+E1( int a2[*];       )
+                                                        #ifndef __cforall
+E1( double a4[3.0];  )                                  // BUG 275: CFA accepts but should reject
+                                                        #endif
+int (*tom())[3] {
+}
+    int m1[0][3];
+E1( int m2[*][*];    )
+    int m4[3][3];
+int (*(jane)())( int T[3],
+                                 int p1[const 3],
+                                 int p2[static 3],
+                                 int p3[static const 3]
+        ) {
+}
+    typedef int T;
+    int fred(int n) {
+E1(     int a1[];    )
+E1(     int a2[*];   )
+        int a4[3];
+        int T[3];
+        int a5[n];
+    }
+    int mary( int T[3],                                 // same as: int *T
+              int p1[const 3],                          // same as: int const *p1
+              int p2[static 3],                         // same as T, but length >=3 checked
+              int p3[static const 3]                    // both above: 3 is static, p3 is const
+        ) {
+    }
+    // function taking (), returning pointer to array of ints
+    int (*tom())[3] {
+    }
+    // function taking (), returning pointer to function of same type as mary
+    int (*(jane)())( int T[3],
+                     int p1[const 3],
+                     int p2[static 3],
+                     int p3[static const 3]
+        ) {
+    }
+    // functions returning same exotic pointers, in CFA's non-onion syntax
+    #ifdef __cforall
+    [ * [3] int ] toms_twin(...) {
+    }
+    [ * [int]( [3] int T,
+               [const 3] int p1,
+               [static 3] int p2,
+               [static const 3] int p3
+             )
+    ] janes_twin(...) {
+    }
+    #endif
+    // GCC 11+ gives a false warning (-Wvla-parameter) on the valid (C11 ARM p134-135) combination:
+    // declare with type int[*], define with type int[n].
+    // https://gcc.gnu.org/bugzilla//show_bug.cgi?id=100420 suggests the internal representation of
+    // of a[*] is the same as a[0].
+    // https://gcc.gnu.org/onlinedocs/gcc/Warning-Options.html#index-Wno-vla-parameter explains
+    // the purpose of -Wvla-parameter is to report conflicts between int[] and int[n], which would
+    // understandably also include those between int[42] and int[n].
+    // https://stackoverflow.com/questions/17371645/why-use-an-asterisk-instead-of-an-integer-for-a-vla-array-parameter-of-a-f
+    // explains the declare-*, define-n pattern.
+    // To work around the false warning, and keep to this test's purpose of exercising CFA's
+    // handling of exotic C array syntax, what would ideally be demonstrated as a declaration of
+    // fm1, followed by its definition, is instead split into fm1x and fm1y.  And similarly for
+    // fm5.
+    int fm1x( int, int, int[][*] );
+    int fm1y( int r, int c, int m[][c] ) {}
+    int fm2( int r, int c, int (*m)[c] ) {}             // same as fm1
+E2( int fm3( int r, int c, int m[][static c] ) {}  )    // that's not static
+E3( int fm4( int r, int c, int m[][] );            )    // m's immediate element type is incomplete
+    int fm5x( int, int, int[*][*] );                    // same as fm1 decl
+                                                        #ifndef __cforall
+    int fm5y( int r, int c, int m[r][c] ) {}            // BUG 276: CFA chokes but should accept
+                                                        // C: same as fm1 defn
+                                                        #endif
 int main() {
     #pragma GCC warning "Compiled"                      // force non-empty .expect file, NO TABS!!!
+    #pragma GCC warning "Preprocessor started"          // force non-empty .expect file, NO TABS!!!
+}

tests/attributes.cfa

-              r34b4268
+              r24d6572
 // Created On       : Mon Feb  6 16:07:02 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Mon Mar 15 13:53:31 2021
 // Update Count     : 38
+// Last Modified On : Thu Feb 23 20:33:07 2023
+// Update Count     : 39
 //
 …
 // aggregate_name
 struct __attribute__(( unused )) {} Dummy;
+static struct __attribute__(( unused )) {} Dummy;
 struct __attribute__(( unused )) Agn1;
 struct __attribute__(( unused )) Agn2 {};

tests/avltree/avl.h

-              r34b4268
+              r24d6572
 // #include <lib.h>
+trait Comparable(T) {
+forall(T)
+trait Comparable {
   int ?<?(T, T);
 };

tests/collections/vector-demo.cfa

r34b4268	r24d6572
143	143	assert( v`capacity > 5 && v`length == 5 );
144	144
145		v[2] = -0.1; // v is [0.0, 98.6, -0.1, 0.2, 0.3]; iter at -0.1, where only the new memory had that change
	145	v[2] = -0.1f; // v is [0.0, 98.6, -0.1, 0.2, 0.3]; iter at -0.1, where only the new memory had that change
146	146
147	147	float val3 = iter`val;

tests/declarationSpecifier.cfa

-              r34b4268
+              r24d6572
 // 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 : Thu Feb 23 20:53:31 2023
+// Update Count     : 8
 //
 …
 short int volatile static const x8;
+const volatile struct { int i; } x10;
+const struct { int i; } volatile x11;
+struct { int i; } const volatile x12;
+static const volatile struct { int i; } x13;
+const static struct { int i; } volatile x14;
+struct { int i; } static const volatile x15;
+struct { int i; } const static volatile x16;
+struct { int i; } const volatile static x17;
+static const volatile struct { int i; } x10;
+static const struct { int i; } volatile x11;
+static struct { int i; } const volatile x12;
+const static struct { int i; } volatile x13;
+struct { int i; } static const volatile x14;
+struct { int i; } const static volatile x15;
+struct { int i; } const volatile static x16;
 const Int volatile x20;
 …
 Int volatile static const x27;
+const volatile struct { Int i; } x29;
+const struct { Int i; } volatile x30;
+struct { Int i; } const volatile x31;
+static const volatile struct { Int i; } x32;
+const static struct { Int i; } volatile x33;
+struct { Int i; } static const volatile x34;
+struct { Int i; } const static volatile x35;
+struct { Int i; } const volatile static x36;
+static const volatile struct { Int i; } x29;
+static const struct { Int i; } volatile x30;
+static struct { Int i; } const volatile x31;
+const static struct { Int i; } volatile x32;
+struct { Int i; } static const volatile x33;
+struct { Int i; } const static volatile x34;
+struct { Int i; } const volatile static x35;
 _Thread_local int x37;

tests/enum_tests/.expect/typedIntEnum.txt

-              r34b4268
+              r24d6572
+=0
+=1
+=1000
+=1001
+=2000
+=2001
+=2002

tests/enum_tests/pointerEnum.cfa

r34b4268	r24d6572
11	11	int main() {
12	12	E * v = First;
13		sout \| "v: " \| e.x;
	13	// sout \| "v: " \| e.x;
14	14	}

tests/enum_tests/typedIntEnum.cfa

-              r34b4268
+              r24d6572
 int main() {
     printf("%d\n", zero);
     printf("%d\n", one);
     printf("%d\n", thousand);
     printf("%d\n", thousand_one);
     printf("%d\n", two_thousand);
     printf("%d\n", two_thousand_one);
     printf("%d\n", two_thousand_two);
+    printf("0=%d\n", zero);
+    printf("1=%d\n", one);
+    printf("1000=%d\n", thousand);
+    printf("1001=%d\n", thousand_one);
+    printf("2000=%d\n", two_thousand);
+    printf("2001=%d\n", two_thousand_one);
+    printf("2002=%d\n", two_thousand_two);
     return 0;
+}

tests/errors/.expect/declaration.txt

-              r34b4268
+              r24d6572
 errors/declaration.cfa:16:1 error: duplicate static in declaration of x1: static const volatile short int
+errors/declaration.cfa:16:1 error: duplicate static storage class(es) in declaration of x1: static const volatile short int
 errors/declaration.cfa:17:1 error: conflicting extern & static in declaration of x2: extern const volatile short int
+errors/declaration.cfa:17:1 error: conflicting extern & static storage classes in declaration of x2: extern const volatile short int
 errors/declaration.cfa:18:1 error: conflicting extern & auto, conflicting extern & static, conflicting extern & static, duplicate extern in declaration of x3: extern const volatile short int
+errors/declaration.cfa:18:1 error: conflicting extern & auto storage classes, conflicting extern & static storage classes, conflicting extern & static storage classes, duplicate extern storage class(es) in declaration of x3: extern const volatile short int
 errors/declaration.cfa:19:1 error: duplicate static in declaration of x4: static const volatile instance of const volatile struct __anonymous0
+errors/declaration.cfa:19:1 error: duplicate static storage class(es) in declaration of x4: static const volatile instance of const volatile struct __anonymous0
   with members
     i: int
 …
 errors/declaration.cfa:20:1 error: duplicate const, duplicate static, duplicate volatile in declaration of x5: static const volatile instance of const volatile struct __anonymous1
+errors/declaration.cfa:20:1 error: duplicate const qualifier(s), duplicate static storage class(es), duplicate volatile qualifier(s) in declaration of x5: static const volatile instance of const volatile struct __anonymous1
   with members
     i: int
 …
 errors/declaration.cfa:22:1 error: duplicate static in declaration of x6: static const volatile Int
+errors/declaration.cfa:22:1 error: duplicate static storage class(es) in declaration of x6: static const volatile Int
 errors/declaration.cfa:24:1 error: duplicate const in declaration of f01: static inline function
+errors/declaration.cfa:24:1 error: duplicate const qualifier(s) in declaration of f01: static inline function
   with no parameters
   returning const volatile int
 errors/declaration.cfa:25:1 error: duplicate volatile in declaration of f02: static inline function
+errors/declaration.cfa:25:1 error: duplicate volatile qualifier(s) in declaration of f02: static inline function
   with no parameters
   returning const volatile int
 errors/declaration.cfa:26:1 error: duplicate const in declaration of f03: static inline function
+errors/declaration.cfa:26:1 error: duplicate const qualifier(s) in declaration of f03: static inline function
   with no parameters
   returning const volatile int
 errors/declaration.cfa:27:1 error: duplicate volatile in declaration of f04: static inline function
+errors/declaration.cfa:27:1 error: duplicate volatile qualifier(s) in declaration of f04: static inline function
   with no parameters
   returning const volatile int
 errors/declaration.cfa:28:1 error: duplicate const in declaration of f05: static inline function
+errors/declaration.cfa:28:1 error: duplicate const qualifier(s) in declaration of f05: static inline function
   with no parameters
   returning const volatile int
 errors/declaration.cfa:29:1 error: duplicate volatile in declaration of f06: static inline function
+errors/declaration.cfa:29:1 error: duplicate volatile qualifier(s) in declaration of f06: static inline function
   with no parameters
   returning const volatile int
 errors/declaration.cfa:30:1 error: duplicate const in declaration of f07: static inline function
+errors/declaration.cfa:30:1 error: duplicate const qualifier(s) in declaration of f07: static inline function
   with no parameters
   returning const volatile int
 errors/declaration.cfa:31:1 error: duplicate const, duplicate volatile in declaration of f08: static inline function
+errors/declaration.cfa:31:1 error: duplicate const volatile qualifier(s) in declaration of f08: static inline function
   with no parameters
   returning const volatile int
 errors/declaration.cfa:33:1 error: duplicate const, duplicate volatile in declaration of f09: static inline function
+errors/declaration.cfa:33:1 error: duplicate const volatile qualifier(s) in declaration of f09: static inline function
   with no parameters
   returning const volatile int
 errors/declaration.cfa:34:1 error: duplicate const, duplicate _Atomic, duplicate _Atomic, duplicate const, duplicate restrict, duplicate volatile in declaration of f09: static inline function
+errors/declaration.cfa:34:1 error: duplicate const qualifier(s), duplicate _Atomic qualifier(s), duplicate _Atomic qualifier(s), duplicate const restrict volatile qualifier(s) in declaration of f09: static inline function
   with no parameters
   returning const restrict volatile _Atomic int

tests/forall.cfa

-              r34b4268
+              r24d6572
 // Created On       : Wed May  9 08:48:15 2018
 // Last Modified By : Peter A. Buhr
+// Last Modified On : Sat Jun  5 10:06:08 2021
+// Update Count     : 36
+//
+// Last Modified On : Thu Feb 23 20:29:59 2023
+// Update Count     : 91
+//
+#include <fstream.hfa>
 void g1() {
+        forall( T ) T f( T ) {};
+        void f( int ) {};
+        void h( void (*p)(void) ) {};
+        int x;
+        void (*y)(void);
+        char z;
+        float w;
+        forall( T ) T f( T p ) { sout | 'f'; return p;  };
+        void f( int p ) { sout | p; };
+        void g( void ) { sout | 'g'; };
+        void h( void (*p)(void) ) { p(); };
+        int x = 1;
+        void (*y)(void) = g;
+        char z = 'a';
+        float w = 3.5;
         f( x );
 …
         f( z );
         f( w );
+        h( y );
+        f( y );
         h( f( y ) );
+}
 void g2() {
         forall( T ) void f( T, T ) {}
         forall( T, U ) void f( T, U ) {}
+        forall( T ) void f( T, T ) { sout | "fT"; }
+        forall( T, U ) void f( T, U ) { sout | "fTU"; }
         int x;
         float y;
+        int *z;
+        float *w;
+        int * z;
+        float * w;
+        f( x, x );
+        f( y, y );
+        f( w, w );
         f( x, y );
         f( z, w );
 …
 forall( T )
+void swap( T left, T right ) {
+        T temp = left;
+        left = right;
+        right = temp;
+}
+trait sumable( T ) {
+void swap( T & left, T & right ) {                                              // by reference
+    T temp = left;
+    left = right;
+    right = temp;
+}
+forall( T )
+[ T, T ] swap( T i, T j ) {                                                             // by value
+    return [ j, i ];
+}
+forall( T ) trait sumable {
         void ?{}( T &, zero_t );                                                        // 0 literal constructor
         T ?+?( T, T );                                                                          // assortment of additions
 …
 }; // sumable
 forall( T | sumable( T ) )                                              // use trait
+forall( T | sumable( T ) )                                                              // use trait
 T sum( size_t size, T a[] ) {
         T total = 0;                                                                            // initialize by 0 constructor
 …
 } // sum
 forall( T | { T ?+?( T, T ); T ?++( T & ); [T] ?+=?( T &,T ); } )
+forall( T | { T ?+?( T, T ); T ?++( T & ); [T] ?+=?( T &, T ); } )
 T twice( T t ) {
         return t + t;
 …
+}
 int fred() {
         int x = 1, y = 2, a[10];
+void fred() {
+        int x = 1, y = 2, a[10] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
         float f;
+        sout | x | y;
         swap( x, y );
+        twice( x );
+        sout | x | y | nl | swap( x, y );
+        // [ x, y ] = swap( y, x );
+        sout | twice( ' ' ) | ' ' | twice( 0hh ) | twice( 1h ) | twice( 0n ) | twice( 2 )
+                 | twice( 3.2f ) | twice( 3.2 ) | twice( 3.2d ) | twice( 3.2+1.5i ) | twice( x );
         f = min( 4.0, 3.0 );
+        sum( 10, a );
+        sout | f | min( 4.0, 3.0 );
+        sout | sum( 10, a );
+}
 …
 forall( T ) struct S { T t; } (int) x, y, z;
 forall( T ) struct { T t; } (int) a, b, c;
+static forall( T ) struct { T t; } (int) a, b, c;
 forall( T ) static forall( S ) {
 …
 forall( T ) {
         extern "C" {
+//      extern "C" {
                 struct SS { T t; };
                 T foo( T ) {}
+        }
+                T foo( T p ) { return p; }
+//      }
+}
 …
 W(int,int) w;
 int jane() {
+void jane() {
 //      int j = bar( 3, 4 );
         int k = baz( 3, 4, 5 );
         int i = foo( 3 );
+        sout | k | i;
+}
 …
         T t;
         T t2 = t;
+        sout | &tr | tp;
+}
 …
 int main( void ) {
+    #pragma GCC warning "Compiled"                      // force non-empty .expect file, NO TABS!!!
+        g1();
+        g2();
+        fred();
+        jane();
+}

tests/function-operator.cfa

-              r34b4268
+              r24d6572
 // 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 : Sat Feb 25 07:26:10 2023
+// Update Count     : 12
 //
 …
 // STL-like Algorithms
+trait Assignable(T &, U &) { T ?=?(T &, U); };
+trait Copyable(T &) { void ?{}(T &, T); };
+trait Destructable(T &) { void ^?{}(T &); };
+forall(T &, U &)
+trait Assignable { T ?=?(T &, U); };
+forall(T &)
+trait Copyable { void ?{}(T &, T); };
+forall(T &)
+trait Destructable { void ^?{}(T &); };
 trait Iterator(iter & | sized(iter) | Copyable(iter) | Destructable(iter), T) {

tests/include/includes.cfa

-              r34b4268
+              r24d6572
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sun May 22 08:27:20 2022
 // Update Count     : 779
+// Last Modified On : Wed Feb 22 10:16:58 2023
+// Update Count     : 811
 //
 …
 #include <gshadow.h>
 #include <iconv.h>
+#include <ifaddrs.h>
+//#include <ifaddrs.h>                                                                  // causes warning messages that break the build
 #include <inttypes.h>
 #include <langinfo.h>
 …
 #include <ncurses_dll.h>                                                                // may not be installed, comes with ncurses
 #endif
 #include <netdb.h>
+//#include <netdb.h>
 #include <nl_types.h>
 #include <nss.h>
 …
 #include <pwd.h>
 #include <regex.h>
 #include <resolv.h>
+//#include <resolv.h>
 #include <re_comp.h>
 #include <sched.h>
 …
 #endif // __CFA__
 int main( int argc, char const * argv[] ) {
+int main() {
     #pragma GCC warning "Compiled"                                                      // force non-empty .expect file, NO TABS!!!
+}

tests/io/comp_basic.cfa

-              r34b4268
+              r24d6572
 #include <unistd.h>
 struct {
+static struct {
         barrier & bar;
         int pipe[2];
 } globals;

tests/io/comp_fair.cfa

-              r34b4268
+              r24d6572
 #include <unistd.h>
 struct {
+static struct {
         barrier & bar;
         int pipe[2];
 } globals;

tests/linking/mangling/header.hfa

-              r34b4268
+              r24d6572
 extern name_but_a_typedefed_t a_typedefed_global;
+extern struct /* anonymous */ {
+        int some_int;
+        int some_other_int;
+} a_global_with_no_type;
+// Must be extern C to prevent name mangling.
+extern "C" {
+        extern struct /* anonymous */ {
+                int some_int;
+                int some_other_int;
+        } a_global_with_no_type;
+}

tests/linking/mangling/lib.cfa

-              r34b4268
+              r24d6572
 name_but_a_typedefed_t a_typedefed_global;
+struct {
+        int some_int;
+        int some_other_int;
+} a_global_with_no_type;
+// Must be extern C to prevent name mangling.
+extern "C" {
+        // This declaration is necessary to create an instance of a_global_with_no_type.
+        // typeof is a trick to get a_global_with_no_type's type because its type is anonymous.
+        // Otherwise C generates conflicting types for a_global_with_no_type in .h and .c
+        // because C uses name equivalence and the two anonymous types cannot have the same name.
+        typeof(a_global_with_no_type) a_global_with_no_type;
+}

tests/linking/mangling/main.cfa

-              r34b4268
+              r24d6572
 #include <fstream.hfa>
 struct { int a; } test; //purposefully before the include
+static struct { int a; } test; // purposefully before the include to force anonymous name numbering
 #include "header.hfa"
 …
         sout | "Done!";
-        return 0;
+}

tests/pybin/settings.py

-              r34b4268
+              r24d6572
         global archive
         global install
+        global invariant
         global continue_
 …
         all_install  = [Install(o)      for o in list(dict.fromkeys(options.install))]
         archive      = os.path.abspath(os.path.join(original_path, options.archive_errors)) if options.archive_errors else None
+        invariant    = options.invariant
         continue_    = options.continue_
         dry_run      = options.dry_run # must be called before tools.config_hash()

tests/quotedKeyword.cfa

-              r34b4268
+              r24d6572
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Feb  7 19:07:07 2020
 // Update Count     : 25
+// Last Modified On : Thu Feb 23 20:31:05 2023
+// Update Count     : 26
 //
 #include <fstream.hfa>
 struct {
+static struct {
         int ``otype;
         int ``struct;

tests/sum.cfa

-              r34b4268
+              r24d6572
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Aug  5 21:27:25 2021
 // Update Count     : 346
+// Last Modified On : Fri Feb 24 22:52:12 2023
+// Update Count     : 347
 //
 …
 #include <stdlib.hfa>
+trait sumable( T ) {
+forall( T )
+trait sumable {
         void ?{}( T &, zero_t );                                                        // 0 literal constructor
         void ?{}( T &, one_t );                                                         // 1 literal constructor

tests/test.py

-              r34b4268
+              r24d6572
         parser.add_argument('--install', help='Run all tests based on installed binaries or tree binaries', type=comma_separated(yes_no), default='no')
         parser.add_argument('--continue', help='When multiple specifications are passed (debug/install/arch), sets whether or not to continue if the last specification failed', type=yes_no, default='yes', dest='continue_')
+        parser.add_argument('--invariant', help='Tell the compiler to check invariants while running.', action='store_true')
         parser.add_argument('--timeout', help='Maximum duration in seconds after a single test is considered to have timed out', type=int, default=180)
         parser.add_argument('--global-timeout', help='Maximum cumulative duration in seconds after the ALL tests are considered to have timed out', type=int, default=7200)
 …
         test.prepare()
+        # extra flags for cfa to pass through make.
+        cfa_flags = 'CFAFLAGS=--invariant' if settings.invariant else None
         # ----------
         # MAKE
 …
         # build, skipping to next test on error
         with Timed() as comp_dur:
                 make_ret, _, _ = make( test.target(), output_file=subprocess.DEVNULL, error=out_file, error_file = err_file )
+                make_ret, _, _ = make(test.target(), flags=cfa_flags, output_file=subprocess.DEVNULL, error=out_file, error_file=err_file)
         # ----------

Context Navigation

Changes in / [34b4268:24d6572]

Legend: