Changes in / [c3a2007:c921712]

Files:

• Jenkinsfile (modified) (1 diff)
• Makefile.in (modified) (1 diff)
• benchmark/Makefile.am (modified) (1 diff)
• benchmark/Makefile.in (modified) (2 diffs)
• configure (modified) (2 diffs)
• configure.ac (modified) (1 diff)
• doc/proposals/approx-equal.md (deleted)
• driver/Makefile.in (modified) (1 diff)
• driver/cc1.cc (modified) (2 diffs)
• driver/cfa.cc (modified) (12 diffs)
• libcfa/Makefile.in (modified) (1 diff)
• libcfa/configure (modified) (4 diffs)
• libcfa/configure.ac (modified) (3 diffs)
• libcfa/prelude/Makefile.in (modified) (1 diff)
• libcfa/prelude/extras.regx (modified) (1 diff)
• libcfa/src/Makefile.am (modified) (2 diffs)
• libcfa/src/Makefile.in (modified) (3 diffs)
• libcfa/src/concurrency/kernel_private.hfa (modified) (1 diff)
• libcfa/src/heap.cfa (modified) (6 diffs)
• libcfa/src/stdlib.cfa (modified) (5 diffs)
• libcfa/src/stdlib.hfa (modified) (6 diffs)
• longrun_tests/Makefile.am (modified) (1 diff)
• longrun_tests/Makefile.in (modified) (2 diffs)
• src/CodeGen/CodeGenerator.cc (modified) (2 diffs)
• src/CodeGen/GenType.cc (modified) (1 diff)
• src/ControlStruct/MLEMutator.cc (modified) (2 diffs)
• src/ControlStruct/MLEMutator.h (modified) (3 diffs)
• src/GenPoly/Box.cc (modified) (1 diff)
• src/GenPoly/Lvalue.cc (modified) (3 diffs)
• src/Makefile.in (modified) (5 diffs)
• src/ResolvExpr/ConversionCost.cc (modified) (1 diff)
• src/ResolvExpr/ResolveAssertions.cc (modified) (1 diff)
• src/SymTab/Autogen.h (modified) (1 diff)
• src/SymTab/ManglerCommon.cc (modified) (1 diff)
• src/SymTab/Validate.cc (modified) (7 diffs)
• src/SynTree/AddressExpr.cc (modified) (1 diff)
• src/SynTree/ApplicationExpr.cc (modified) (2 diffs)
• src/SynTree/ArrayType.cc (modified) (1 diff)
• src/SynTree/CommaExpr.cc (modified) (2 diffs)
• src/SynTree/Expression.cc (modified) (16 diffs)
• src/SynTree/Expression.h (modified) (1 diff)
• src/SynTree/TopLvalue.cc (added)
• src/SynTree/TopLvalue.h (added)
• src/SynTree/TupleExpr.cc (modified) (3 diffs)
• src/SynTree/Type.cc (modified) (1 diff)
• src/SynTree/Type.h (modified) (4 diffs)
• src/SynTree/module.mk (modified) (1 diff)
• src/Tuples/TupleExpansion.cc (modified) (1 diff)
• src/main.cc (modified) (10 diffs)
• tests/.expect/alloc-ERROR.txt (modified) (4 diffs)
• tests/.expect/alloc.txt (modified) (4 diffs)
• tests/.expect/attributes.x64.txt (modified) (1 diff)
• tests/.expect/attributes.x86.txt (modified) (1 diff)
• tests/Makefile.am (modified) (3 diffs)
• tests/Makefile.in (modified) (4 diffs)
• tests/alloc.cfa (modified) (10 diffs)
• tests/concurrent/examples/quickSort.cfa (modified) (4 diffs)
• tests/labelledExit.cfa (modified) (2 diffs)
• tests/pybin/settings.py (modified) (1 diff)
• tests/pybin/tools.py (modified) (1 diff)
• tools/Makefile.in (modified) (1 diff)
• tools/PrettyGitLogs.sh (added)
• tools/prettyprinter/Makefile.in (modified) (1 diff)

Jenkinsfile

@@ -224 +224 @@
 //Routine responsible of sending the email notification once the build is completed
 //===========================================================================================================
-@NonCPS
-def SplitLines(String text) {
-        def list = []
-
-        text.eachLine {
-                list += it
-        }
-
-        return list
-}
-
 def GitLogMessage() {
         if (!Settings || !Settings.GitOldRef || !Settings.GitNewRef) return "\nERROR retrieveing git information!\n"
 
-        def oldRef = Settings.GitOldRef
-        def newRef = Settings.GitNewRef
-
-        def revText = sh(returnStdout: true, script: "git rev-list ${oldRef}..${newRef}").trim()
-        def revList = SplitLines( revText )
-
-        def gitUpdate = ""
-        revList.each { rev ->
-                def type = sh(returnStdout: true, script: "git cat-file -t ${rev}").trim()
-                gitUpdate = gitUpdate + "       via  ${rev} (${type})"
-        }
-
-        def rev = oldRef
-        def type = sh(returnStdout: true, script: "git cat-file -t ${rev}").trim()
-        gitUpdate = gitUpdate + "      from  ${rev} (${type})"
-
-        def gitLog    = sh(returnStdout: true, script: "git rev-list --format=short ${oldRef}...${newRef}").trim()
-
-        def gitDiff   = sh(returnStdout: true, script: "git diff --stat --color ${newRef} ${oldRef}").trim()
-        gitDiff = gitDiff.replace('[32m', '<span style="color: #00AA00;">')
-        gitDiff = gitDiff.replace('[31m', '<span style="color: #AA0000;">')
-        gitDiff = gitDiff.replace('[m', '</span>')
+        sh "${SrcDir}/tools/PrettyGitLogs.sh ${SrcDir} ${BuildDir} ${Settings.GitOldRef} ${Settings.GitNewRef}"
+
+        def gitUpdate = readFile("${BuildDir}/GIT_UPDATE")
+        def gitLog    = readFile("${BuildDir}/GIT_LOG")
+        def gitDiff   = readFile("${BuildDir}/GIT_DIFF")
 
         return """

Makefile.in

@@ -264 +264 @@
 CCDEPMODE = @CCDEPMODE@
 CFACC = @CFACC@
-CFACC_INSTALL = @CFACC_INSTALL@
 CFACPP = @CFACPP@
 CFA_BACKEND_CC = @CFA_BACKEND_CC@

benchmark/Makefile.am

@@ -22 +22 @@
 
 AM_CFLAGS = -O2 -Wall -Wextra -I$(srcdir) -lrt -pthread # -Werror
-AM_CFAFLAGS = -quiet -nodebug
+AM_CFAFLAGS = -quiet -nodebug -in-tree
 AM_UPPFLAGS = -quiet -nodebug -multi -std=c++14
 

benchmark/Makefile.in

@@ -214 +214 @@
 CCDEPMODE = @CCDEPMODE@
 CFACC = @CFACC@
-CFACC_INSTALL = @CFACC_INSTALL@
 CFACPP = @CFACPP@
 CFA_BACKEND_CC = @CFA_BACKEND_CC@
@@ -376 +375 @@
 # applies to both programs
 AM_CFLAGS = -O2 -Wall -Wextra -I$(srcdir) -lrt -pthread # -Werror
-AM_CFAFLAGS = -quiet -nodebug
+AM_CFAFLAGS = -quiet -nodebug -in-tree
 AM_UPPFLAGS = -quiet -nodebug -multi -std=c++14
 BENCH_V_CC = $(__bench_v_CC_$(__quiet))

configure

@@ -715 +715 @@
 BUILD_IN_TREE_FLAGS
 CFACPP
-CFACC_INSTALL
 CFACC
 DRIVER_DIR
@@ -3304 +3303 @@
 DRIVER_DIR=${TOP_BUILDDIR}driver/
 CFACC=${DRIVER_DIR}cfa
-CFACC_INSTALL=${CFA_BINDIR}${CFA_NAME}
 CFACPP=${DRIVER_DIR}cfa-cpp
-
 
 

configure.ac

@@ -93 +93 @@
 DRIVER_DIR=${TOP_BUILDDIR}driver/
 CFACC=${DRIVER_DIR}cfa
-CFACC_INSTALL=${CFA_BINDIR}${CFA_NAME}
 CFACPP=${DRIVER_DIR}cfa-cpp
 AC_SUBST(DRIVER_DIR)
 AC_SUBST(CFACC)
-AC_SUBST(CFACC_INSTALL)
 AC_SUBST(CFACPP)
 

driver/Makefile.in

@@ -201 +201 @@
 CCDEPMODE = @CCDEPMODE@
 CFACC = @CFACC@
-CFACC_INSTALL = @CFACC_INSTALL@
 CFACPP = @CFACPP@
 CFA_BACKEND_CC = @CFA_BACKEND_CC@

driver/cc1.cc

@@ -10 +10 @@
 // Created On       : Fri Aug 26 14:23:51 2005
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sun Oct 20 08:14:33 2019
-// Update Count     : 385
+// Last Modified On : Mon Sep  9 17:50:53 2019
+// Update Count     : 384
 //
 
@@ -503 +503 @@
                 execvp( args[0], (char * const *)args );                // should not return
                 perror( "CC1 Translator error: stage 2 cc1, execvp" );
-                cerr << " invoked " << args[0] << endl;
+                cerr << " invoked " << cargs[0] << endl;
                 exit( EXIT_FAILURE );                                                   // tell gcc not to go any further
         } // if

driver/cfa.cc

@@ -15 +15 @@
 
 #include <iostream>
-#include <cstdio>      // perror
-#include <cstdlib>     // putenv, exit
-#include <climits>     // PATH_MAX
-#include <unistd.h>    // execvp
-#include <string>      // STL version
-#include <string.h>    // strcmp
-#include <algorithm>   // find
+#include <cstdio>                                                                               // perror
+#include <cstdlib>                                                                              // putenv, exit
+#include <unistd.h>                                                                             // execvp
+#include <string>                                                                               // STL version
+#include <string.h>                                                                             // strcmp
+#include <algorithm>                                                                    // find
 
 #include <sys/types.h>
@@ -36 +35 @@
 // #define __DEBUG_H__
 
-// "N__=" suffix
-static string __CFA_FLAGPREFIX__( "__CFA_FLAG" );
+static string __CFA_FLAGPREFIX__( "__CFA_FLAG" );               // "N__=" suffix
 
 void Putenv( char * argv[], string arg ) {
@@ -59 +57 @@
 }
 
-// check if string has suffix
-bool suffix( const string & arg ) {
+bool suffix( const string & arg ) {                                             // check if string has suffix
         enum { NumSuffixes = 3 };
         static const string suffixes[NumSuffixes] = { "cfa", "hfa", "ifa" };
@@ -79 +76 @@
 static inline string dir(const string & path) {
         return path.substr(0, path.find_last_of('/'));
-}
-
-// Different path modes
-enum PathMode {
-        Installed,     // cfa is installed, use prefix
-        BuildTree,     // cfa is in the tree, use source and build tree
-        Distributed    // cfa is distributed, use build tree for includes and executable directory for .cfs
-};
-
-// Get path mode from /proc
-PathMode FromProc() {
-        std::string abspath;
-        abspath.resize(PATH_MAX);
-
-        // get executable path from /proc/self/exe
-        ssize_t size = readlink("/proc/self/exe", const_cast<char*>(abspath.c_str()), abspath.size());
-        if(size <= 0) {
-                std::cerr << "Error could not evaluate absolute path from /proc/self/exe" << std::endl;
-                std::cerr << "Failed with " << std::strerror(errno) << std::endl;
-                std::exit(1);
-        }
-
-        // Trim extra characters
-        abspath.resize(size);
-
-        // Are we installed
-        if(abspath.rfind(CFA_BINDIR  , 0) == 0) { return Installed; }
-
-        // Is this the build tree
-        if(abspath.rfind(TOP_BUILDDIR, 0) == 0) { return BuildTree; }
-
-        // Does this look like distcc
-        if(abspath.find("/.cfadistcc/") != std::string::npos) { return Distributed; }
-
-        // None of the above? Give up since we don't know where the prelude or include directories are
-        std::cerr << "Cannot find required files from excutable path " << abspath << std::endl;
-        std::exit(1);
 }
 
@@ -153 +113 @@
         bool m32 = false;                                                                       // -m32 flag
         bool m64 = false;                                                                       // -m64 flag
+        bool intree = false;                                                            // build in tree
         bool compiling_libs = false;
+        bool disttree = false;
         int o_file = 0;                                                                         // -o filename position
-
-        PathMode path = FromProc();
 
         const char *args[argc + 100];                                           // cfa command line values, plus some space for additional flags
@@ -211 +171 @@
                         } else if ( arg == "-no-include-stdhdr" ) {
                                 noincstd_flag = true;                                   // strip the no-include-stdhdr flag
+                        } else if ( arg == "-in-tree" ) {
+                                intree = true;
+                        } else if ( arg == "-dist-tree" ) {
+                                disttree = true;
                         } else if ( arg == "-cfalib") {
                                 compiling_libs = true;
@@ -319 +283 @@
 
         // add the CFA include-library paths, which allow direct access to header files without directory qualification
-        string libbase;
-        switch(path) {
-        case Installed:
+        if ( ! intree ) {
                 args[nargs++] = "-I" CFA_INCDIR;
-                // do not use during build
-                if ( ! noincstd_flag ) {
+                if ( ! noincstd_flag ) {                                                // do not use during build
                         args[nargs++] = "-I" CFA_INCDIR "stdhdr";
                 } // if
                 args[nargs++] = "-I" CFA_INCDIR "concurrency";
                 args[nargs++] = "-I" CFA_INCDIR "containers";
-                libbase = CFA_LIBDIR;
-                break;
-        case BuildTree:
-        case Distributed:
+        } else {
                 args[nargs++] = "-I" TOP_SRCDIR "libcfa/src";
-                // do not use during build
-                if ( ! noincstd_flag ) {
+                if ( ! noincstd_flag ) {                                                // do not use during build
                         args[nargs++] = "-I" TOP_SRCDIR "libcfa/src" "/stdhdr";
                 } // if
                 args[nargs++] = "-I" TOP_SRCDIR "libcfa/src" "/concurrency";
                 args[nargs++] = "-I" TOP_SRCDIR "libcfa/src" "/containers";
-
-                libbase = TOP_BUILDDIR "libcfa/";
-
-                break;
         } // if
 
@@ -349 +302 @@
         args[nargs++] = "-imacros";
         args[nargs++] = "stdbool.h";
+
+        string libbase;
+        if ( ! intree ) {
+                libbase = CFA_LIBDIR;
+        } else {
+                libbase = TOP_BUILDDIR "libcfa/";
+        } // if
 
         if( compiling_libs ) {
@@ -366 +326 @@
         string libdir = libbase + arch + "-" + config;
 
-        if (path != Distributed) {
+        if (!disttree) {
                 if ( ! nolib && ! dirExists( libdir ) ) {
                         cerr << argv[0] << " internal error, configuration " << config << " not installed." << endl;
@@ -384 +344 @@
         } // if
 
-        switch(path) {
-        case Installed   : Putenv( argv, "--prelude-dir=" + libdir ); break;
-        case BuildTree   : Putenv( argv, "--prelude-dir=" + libdir + "/prelude" ); break;
-        case Distributed : Putenv( argv, "--prelude-dir=" + dir(argv[0]) ); break;
+        if(disttree) {
+                Putenv( argv, "--prelude-dir=" + dir(argv[0]) );
+        } else if(intree) {
+                Putenv( argv, "--prelude-dir=" + libdir + "/prelude" );
+        } else {
+                Putenv( argv, "--prelude-dir=" + libdir );
         }
 
@@ -403 +365 @@
 
                 // include the cfa library in case it is needed
-                args[nargs++] = ( *new string( string("-L" ) + libdir + (path != Installed ? "/src/.libs" : "")) ).c_str();
-                args[nargs++] = ( *new string( string("-Wl,-rpath," ) + libdir + (path != Installed ? "/src/.libs" : "")) ).c_str();
+                args[nargs++] = ( *new string( string("-L" ) + libdir + (intree ? "/src/.libs" : "")) ).c_str();
+                args[nargs++] = ( *new string( string("-Wl,-rpath," ) + libdir + (intree ? "/src/.libs" : "")) ).c_str();
                 args[nargs++] = "-Wl,--push-state,--as-needed";
                 args[nargs++] = "-lcfathread";
@@ -448 +410 @@
 
         if ( bprefix.length() == 0 ) {
-                switch(path) {
-                case Installed   : bprefix = installlibdir; break;
-                case BuildTree   : bprefix = srcdriverdir ; break;
-                case Distributed : bprefix = dir(argv[0]) ; break;
+                if(disttree) {
+                        bprefix = dir(argv[0]);
+                } else if(intree) {
+                        bprefix = srcdriverdir;
+                } else {
+                        bprefix = installlibdir;
                 }
                 if ( bprefix[bprefix.length() - 1] != '/' ) bprefix += '/';

libcfa/Makefile.in

@@ -296 +296 @@
 PACKAGE_VERSION = @PACKAGE_VERSION@
 PATH_SEPARATOR = @PATH_SEPARATOR@
+PRELUDEFLAG = @PRELUDEFLAG@
 RANLIB = @RANLIB@
 SED = @SED@

libcfa/configure

@@ -707 +707 @@
 CONFIG_CFLAGS
 ARCH_FLAGS
+PRELUDEFLAG
 CFADIR_HASH
 LOCAL_CC1
@@ -2959 +2960 @@
 if test x$enable_distcc = xno; then
         CFACC=${DRIVER_DIR}cfa
+        PRELUDEFLAG='-in-tree'
         echo "no"
 else
@@ -2966 +2968 @@
         CFADIR_HASH=$($tools/distcc_hash $config)
         CFACC="distcc ~/.cfadistcc/${CFADIR_HASH}/cfa"
+        PRELUDEFLAG='-dist-tree'
         echo "yes (hash=${CFADIR_HASH})"
 fi
@@ -2979 +2982 @@
   ENABLE_DISTCC_FALSE=
 fi
+
 
 

libcfa/configure.ac

@@ -34 +34 @@
 if test x$enable_distcc = xno; then
         CFACC=${DRIVER_DIR}cfa
+        PRELUDEFLAG='-in-tree'
         echo "no"
 else
@@ -41 +42 @@
         CFADIR_HASH=$($tools/distcc_hash $config)
         CFACC="distcc ~/.cfadistcc/${CFADIR_HASH}/cfa"
+        PRELUDEFLAG='-dist-tree'
         echo "yes (hash=${CFADIR_HASH})"
 fi
@@ -55 +57 @@
 AC_SUBST(CFADIR_HASH)
 AC_SUBST(CFA_VERSION)
+AC_SUBST(PRELUDEFLAG)
 
 #==============================================================================

libcfa/prelude/Makefile.in

@@ -239 +239 @@
 PACKAGE_VERSION = @PACKAGE_VERSION@
 PATH_SEPARATOR = @PATH_SEPARATOR@
+PRELUDEFLAG = @PRELUDEFLAG@
 RANLIB = @RANLIB@
 SED = @SED@

libcfa/prelude/extras.regx

@@ -19 +19 @@
 typedef.* uint32_t;
 typedef.* uint64_t;
-typedef.* __uint_least16_t;
-typedef.* __uint_least32_t;
 typedef.* char16_t;
 typedef.* char32_t;

libcfa/src/Makefile.am

@@ -32 +32 @@
 # use -no-include-stdhdr to prevent rebuild cycles
 # The built sources must not depend on the installed headers
-AM_CFAFLAGS = -quiet -cfalib -I$(srcdir)/stdhdr $(if $(findstring ${gdbwaittarget}, ${@}), -XCFA --gdb) @CONFIG_CFAFLAGS@
+AM_CFAFLAGS = -quiet -cfalib @PRELUDEFLAG@ -I$(srcdir)/stdhdr $(if $(findstring ${gdbwaittarget}, ${@}), -XCFA --gdb) @CONFIG_CFAFLAGS@
 AM_CFLAGS = -g -Wall -Wno-unused-function -fPIC @ARCH_FLAGS@ @CONFIG_CFLAGS@
 AM_CCASFLAGS = -g -Wall -Wno-unused-function @ARCH_FLAGS@ @CONFIG_CFLAGS@
@@ -96 +96 @@
 
 prelude.o : prelude.cfa extras.cf gcc-builtins.cf builtins.cf @LOCAL_CFACC@ @CFACPP@
-        ${AM_V_GEN}$(CFACOMPILE) -quiet -XCFA -l ${<} -c -o ${@}
+        ${AM_V_GEN}$(CFACOMPILE) -quiet @PRELUDEFLAG@ -XCFA -l ${<} -c -o ${@}
 
 prelude.lo: prelude.cfa extras.cf gcc-builtins.cf builtins.cf @LOCAL_CFACC@ @CFACPP@
         ${AM_V_GEN}$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile \
-        $(CFACOMPILE) -quiet -XCFA -l ${<} -c -o ${@}
+        $(CFACOMPILE) -quiet @PRELUDEFLAG@ -XCFA -l ${<} -c -o ${@}
 
 #----------------------------------------------------------------------------------------------------------------

libcfa/src/Makefile.in

@@ -349 +349 @@
 PACKAGE_VERSION = @PACKAGE_VERSION@
 PATH_SEPARATOR = @PATH_SEPARATOR@
+PRELUDEFLAG = @PRELUDEFLAG@
 RANLIB = @RANLIB@
 SED = @SED@
@@ -444 +445 @@
 # use -no-include-stdhdr to prevent rebuild cycles
 # The built sources must not depend on the installed headers
-AM_CFAFLAGS = -quiet -cfalib -I$(srcdir)/stdhdr $(if $(findstring ${gdbwaittarget}, ${@}), -XCFA --gdb) @CONFIG_CFAFLAGS@
+AM_CFAFLAGS = -quiet -cfalib @PRELUDEFLAG@ -I$(srcdir)/stdhdr $(if $(findstring ${gdbwaittarget}, ${@}), -XCFA --gdb) @CONFIG_CFAFLAGS@
 AM_CFLAGS = -g -Wall -Wno-unused-function -fPIC @ARCH_FLAGS@ @CONFIG_CFLAGS@
 AM_CCASFLAGS = -g -Wall -Wno-unused-function @ARCH_FLAGS@ @CONFIG_CFLAGS@
@@ -953 +954 @@
 
 prelude.o : prelude.cfa extras.cf gcc-builtins.cf builtins.cf @LOCAL_CFACC@ @CFACPP@
-        ${AM_V_GEN}$(CFACOMPILE) -quiet -XCFA -l ${<} -c -o ${@}
+        ${AM_V_GEN}$(CFACOMPILE) -quiet @PRELUDEFLAG@ -XCFA -l ${<} -c -o ${@}
 
 prelude.lo: prelude.cfa extras.cf gcc-builtins.cf builtins.cf @LOCAL_CFACC@ @CFACPP@
         ${AM_V_GEN}$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile \
-        $(CFACOMPILE) -quiet -XCFA -l ${<} -c -o ${@}
+        $(CFACOMPILE) -quiet @PRELUDEFLAG@ -XCFA -l ${<} -c -o ${@}
 
 #----------------------------------------------------------------------------------------------------------------

libcfa/src/concurrency/kernel_private.hfa

@@ -34 +34 @@
 static inline void WakeThread( thread_desc * thrd ) {
         if( !thrd ) return;
-
-        verify(thrd->state == Inactive);
 
         disable_interrupts();

libcfa/src/heap.cfa

@@ -10 +10 @@
 // Created On       : Tue Dec 19 21:58:35 2017
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Oct 18 07:42:09 2019
-// Update Count     : 556
+// Last Modified On : Wed Jul 24 13:12:45 2019
+// Update Count     : 550
 //
 
@@ -541 +541 @@
         // along with the block and is a multiple of the alignment size.
 
-  if ( unlikely( size > ~0ul - sizeof(HeapManager.Storage) ) ) return 0;
         size_t tsize = size + sizeof(HeapManager.Storage);
         if ( likely( tsize < mmapStart ) ) {                            // small size => sbrk
@@ -593 +592 @@
                 block->header.kind.real.home = freeElem;                // pointer back to free list of apropriate size
         } else {                                                                                        // large size => mmap
-  if ( unlikely( size > ~0ul - pageSize ) ) return 0;
                 tsize = libCeiling( tsize, pageSize );                  // must be multiple of page size
                 #ifdef __STATISTICS__
@@ -890 +888 @@
         } // realloc
 
+
         // The obsolete function memalign() allocates size bytes and returns a pointer to the allocated memory. The memory
         // address will be a multiple of alignment, which must be a power of two.
@@ -993 +992 @@
         size_t malloc_alignment( void * addr ) {
           if ( unlikely( addr == 0 ) ) return libAlign();       // minimum alignment
-                HeapManager.Storage.Header * header = headerAddr( addr );
+                HeapManager.Storage.Header * header = (HeapManager.Storage.Header *)( (char *)addr - sizeof(HeapManager.Storage) );
                 if ( (header->kind.fake.alignment & 1) == 1 ) { // fake header ?
                         return header->kind.fake.alignment & -2;        // remove flag from value
@@ -1005 +1004 @@
         bool malloc_zero_fill( void * addr ) {
           if ( unlikely( addr == 0 ) ) return false;            // null allocation is not zero fill
-                HeapManager.Storage.Header * header = headerAddr( addr );
+
+                HeapManager.Storage.Header * header = (HeapManager.Storage.Header *)( (char *)addr - sizeof(HeapManager.Storage) );
                 if ( (header->kind.fake.alignment & 1) == 1 ) { // fake header ?
                         header = (HeapManager.Storage.Header *)((char *)header - header->kind.fake.offset);

libcfa/src/stdlib.cfa

@@ -10 +10 @@
 // Created On       : Thu Jan 28 17:10:29 2016
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Tue Oct 22 08:57:52 2019
-// Update Count     : 478
+// Last Modified On : Mon Jun 24 17:34:44 2019
+// Update Count     : 462
 //
 
@@ -21 +21 @@
 #include <string.h>                                                                             // memcpy, memset
 #include <malloc.h>                                                                             // malloc_usable_size
-//#include <math.h>                                                                             // fabsf, fabs, fabsl
+#include <math.h>                                                                               // fabsf, fabs, fabsl
 #include <complex.h>                                                                    // _Complex_I
 #include <assert.h>
@@ -27 +27 @@
 //---------------------------------------
 
-forall( dtype T | sized(T) ) {
-        T * alloc_set( T ptr[], size_t dim, char fill ) {       // realloc array with fill
-                size_t olen = malloc_usable_size( ptr );                // current allocation
-                char * nptr = (char *)realloc( (void *)ptr, dim * sizeof(T) ); // C realloc
-                size_t nlen = malloc_usable_size( nptr );               // new allocation
-                if ( nlen > olen ) {                                                    // larger ?
-                        memset( nptr + olen, (int)fill, nlen - olen ); // initialize added storage
-                } // if
-                return (T *)nptr;
-        } // alloc_set
-
-        T * alloc_align( T ptr[], size_t align ) {                      // aligned realloc array
-                char * nptr;
-                size_t alignment = malloc_alignment( ptr );
-                if ( align != alignment && (uintptr_t)ptr % align != 0 ) {
-                        size_t olen = malloc_usable_size( ptr );        // current allocation
-                        nptr = (char *)memalign( align, olen );
-                        size_t nlen = malloc_usable_size( nptr );       // new allocation
-                        size_t lnth = olen < nlen ? olen : nlen;        // min
-                        memcpy( nptr, ptr, lnth );                                      // initialize storage
-                        free( ptr );
-                } else {
-                        nptr = (char *)ptr;
-                } // if
-                return (T *)nptr;
-        } // alloc_align
-
-        T * alloc_align( T ptr[], size_t align, size_t dim ) { // aligned realloc array
-                char * nptr;
-                size_t alignment = malloc_alignment( ptr );
-                if ( align != alignment ) {
-                        size_t olen = malloc_usable_size( ptr );        // current allocation
-                        nptr = (char *)memalign( align, dim * sizeof(T) );
-                        size_t nlen = malloc_usable_size( nptr );       // new allocation
-                        size_t lnth = olen < nlen ? olen : nlen;        // min
-                        memcpy( nptr, ptr, lnth );                                      // initialize storage
-                        free( ptr );
-                } else {
-                        nptr = (char *)realloc( (void *)ptr, dim * sizeof(T) ); // C realloc
-                } // if
-                return (T *)nptr;
-        } // alloc_align
-
-        T * alloc_align_set( T ptr[], size_t align, char fill ) { // aligned realloc with fill
-                size_t olen = malloc_usable_size( ptr );                // current allocation
-                char * nptr = alloc_align( ptr, align );
-                size_t nlen = malloc_usable_size( nptr );               // new allocation
-                if ( nlen > olen ) {                                                    // larger ?
-                        memset( nptr + olen, (int)fill, nlen - olen ); // initialize added storage
-                } // if
-                return (T *)nptr;
-        } // alloc_align_set
-} // distribution
+// resize, non-array types
+forall( dtype T | sized(T) ) T * alloc( T ptr[], size_t dim, char fill ) {
+        size_t olen = malloc_usable_size( ptr );                        // current allocation
+    char * nptr = (void *)realloc( (void *)ptr, dim * (size_t)sizeof(T) ); // C realloc
+        size_t nlen = malloc_usable_size( nptr );                       // new allocation
+        if ( nlen > olen ) {                                                            // larger ?
+                memset( nptr + olen, (int)fill, nlen - olen );  // initialize added storage
+        } //
+    return (T *)nptr;
+} // alloc
 
 // allocation/deallocation and constructor/destructor, non-array types
 forall( dtype T | sized(T), ttype Params | { void ?{}( T &, Params ); } )
 T * new( Params p ) {
-        return &(*malloc()){ p };                                                       // run constructor
+        return &(*malloc()){ p };                                                               // run constructor
 } // new
 
@@ -90 +47 @@
 void delete( T * ptr ) {
         if ( ptr ) {                                                                            // ignore null
-                ^(*ptr){};                                                                              // run destructor
+                ^(*ptr){};                                                                                      // run destructor
                 free( ptr );
         } // if
@@ -98 +55 @@
 void delete( T * ptr, Params rest ) {
         if ( ptr ) {                                                                            // ignore null
-                ^(*ptr){};                                                                              // run destructor
+                ^(*ptr){};                                                                                      // run destructor
                 free( ptr );
         } // if

libcfa/src/stdlib.hfa

@@ -10 +10 @@
 // Created On       : Thu Jan 28 17:12:35 2016
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sun Oct 20 22:57:33 2019
-// Update Count     : 390
+// Last Modified On : Tue Jul 23 14:14:59 2019
+// Update Count     : 373
 //
 
@@ -25 +25 @@
         void * memset( void * dest, int fill, size_t size ); // string.h
         void * memcpy( void * dest, const void * src, size_t size ); // string.h
-    void * cmemalign( size_t alignment, size_t noOfElems, size_t elemSize ); // CFA heap
+    void * cmemalign( size_t alignment, size_t noOfElems, size_t elemSize ); // CFA
 } // extern "C"
 
@@ -52 +52 @@
         T * realloc( T * ptr, size_t size ) {
                 if ( unlikely( ptr == 0 ) ) return malloc();
-                return (T *)(void *)realloc( (void *)ptr, size ); // C realloc
+                return (T *)(void *)realloc( (void *)ptr, size );
         } // realloc
 
         T * memalign( size_t align ) {
-                return (T *)memalign( align, sizeof(T) );               // C memalign
+                return (T *)memalign( align, sizeof(T) );
         } // memalign
 
         T * aligned_alloc( size_t align ) {
-                return (T *)aligned_alloc( align, sizeof(T) );  // C aligned_alloc
+                return (T *)aligned_alloc( align, sizeof(T) );
         } // aligned_alloc
 
@@ -67 +67 @@
         } // posix_memalign
 
+
         // Cforall dynamic allocation
 
@@ -73 +74 @@
         } // alloc
 
+        T * alloc( char fill ) {
+                T * ptr;
+                if ( _Alignof(T) <= libAlign() ) ptr = (T *)(void *)malloc( (size_t)sizeof(T) ); // C malloc
+                else ptr = (T *)memalign( _Alignof(T), sizeof(T) );
+                return (T *)memset( ptr, (int)fill, sizeof(T) ); // initialize with fill value
+        } // alloc
+
         T * alloc( size_t dim ) {
-                if ( _Alignof(T) <= libAlign() ) return (T *)(void *)malloc( dim * (size_t)sizeof(T) );
+                if ( _Alignof(T) <= libAlign() ) return (T *)(void *)malloc( dim * (size_t)sizeof(T) ); // C malloc
                 else return (T *)memalign( _Alignof(T), dim * sizeof(T) );
         } // alloc
 
-        T * alloc( T ptr[], size_t dim ) {                                      // realloc
+        T * alloc( size_t dim, char fill ) {
+                return (T *)memset( (T *)alloc( dim ), (int)fill, dim * sizeof(T) ); // initialize with fill value
+        } // alloc
+
+        T * alloc( T ptr[], size_t dim ) {
                 return realloc( ptr, dim * sizeof(T) );
         } // alloc
-
-        T * alloc_set( char fill ) {
-                return (T *)memset( (T *)alloc(), (int)fill, sizeof(T) ); // initialize with fill value
-        } // alloc
-
-        T * alloc_set( T fill ) {
-                return (T *)memcpy( (T *)alloc(), &fill, sizeof(T) ); // initialize with fill value
-        } // alloc
-
-        T * alloc_set( size_t dim, char fill ) {
-                return (T *)memset( (T *)alloc( dim ), (int)fill, dim * sizeof(T) ); // initialize with fill value
-        } // alloc
-
-        T * alloc_set( size_t dim, T fill ) {
-                T * r = (T *)alloc( dim );
-                for ( i; dim ) { memcpy( &r[i], &fill, sizeof(T) ); } // initialize with fill value
-                return r;
-        } // alloc
-
-        T * alloc_set( size_t dim, const T fill[] ) {
-                return (T *)memcpy( (T *)alloc( dim ), fill, dim * sizeof(T) ); // initialize with fill value
-        } // alloc
-} // distribution
-
-forall( dtype T | sized(T) ) {
-        T * alloc_set( T ptr[], size_t dim, char fill );        // realloc array with fill
-} // distribution
-
-static inline forall( dtype T | sized(T) ) {
-        T * alloc_align( size_t align ) {
+} // distribution
+
+
+static inline forall( dtype T | sized(T) ) {
+        T * align_alloc( size_t align ) {
                 return (T *)memalign( align, sizeof(T) );
-        } // alloc_align
-
-        T * alloc_align( size_t align, size_t dim ) {
+        } // align_alloc
+
+        T * align_alloc( size_t align, char fill ) {
+                T * ptr = (T *)memalign( align, sizeof(T) );
+                return (T *)memset( ptr, (int)fill, sizeof(T) );
+        } // align_alloc
+
+        T * align_alloc( size_t align, size_t dim ) {
                 return (T *)memalign( align, dim * sizeof(T) );
-        } // alloc_align
-
-        T * alloc_align_set( size_t align, char fill ) {
-                return (T *)memset( (T *)alloc_align( align ), (int)fill, sizeof(T) ); // initialize with fill value
-        } // alloc_align
-
-        T * alloc_align_set( size_t align, T fill ) {
-                return (T *)memcpy( (T *)alloc_align( align ), &fill, sizeof(T) ); // initialize with fill value
-        } // alloc_align
-
-        T * alloc_align_set( size_t align, size_t dim, char fill ) {
-                return (T *)memset( (T *)alloc_align( align, dim ), (int)fill, dim * sizeof(T) ); // initialize with fill value
-        } // alloc_align
-
-        T * alloc_align_set( size_t align, size_t dim, T fill ) {
-                T * r = (T *)alloc_align( align, dim );
-                for ( i; dim ) { memcpy( &r[i], &fill, sizeof(T) ); } // initialize with fill value
-                return r;
-        } // alloc_align
-
-        T * alloc_align_set( size_t align, size_t dim, const T fill[] ) {
-                return (T *)memcpy( (T *)alloc_align( align, dim ), fill, dim * sizeof(T) );
-        } // alloc_align
-} // distribution
-
-forall( dtype T | sized(T) ) {
-        T * alloc_align( T ptr[], size_t align );                       // realign
-        T * alloc_align( T ptr[], size_t align, size_t dim ); // aligned realloc array
-        T * alloc_align_set( T ptr[], size_t align, size_t dim, char fill ); // aligned realloc array with fill
-} // distribution
+        } // align_alloc
+
+        T * align_alloc( size_t align, size_t dim, char fill ) {
+                if ( fill == '\0' ) {
+                        return (T *)cmemalign( align, dim, sizeof(T) );
+                } else {
+                        return (T *)memset( (T *)memalign( align, dim * sizeof(T) ), (int)fill, dim * sizeof(T) );
+                } // if
+        } // align_alloc
+} // distribution
+
+forall( dtype T | sized(T) ) T * alloc( T ptr[], size_t dim, char fill );
+
 
 static inline forall( dtype T | sized(T) ) {
         // data, non-array types
+
         T * memset( T * dest, char fill ) {
                 return (T *)memset( dest, fill, sizeof(T) );
@@ -160 +136 @@
 static inline forall( dtype T | sized(T) ) {
         // data, array types
+
         T * amemset( T dest[], char fill, size_t dim ) {
                 return (T *)(void *)memset( dest, fill, dim * sizeof(T) ); // C memset

longrun_tests/Makefile.am

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

longrun_tests/Makefile.in

@@ -348 +348 @@
 CCDEPMODE = @CCDEPMODE@
 CFACC = @CFACC@
-CFACC_INSTALL = @CFACC_INSTALL@
 CFACPP = @CFACPP@
 CFA_BACKEND_CC = @CFA_BACKEND_CC@
@@ -526 +525 @@
         -I$(abs_top_srcdir)/tests \
         -I$(srcdir) \
-        -DTEST_$(shell cat .type | tr a-z A-Z)
+        -DTEST_$(shell cat .type | tr a-z A-Z) \
+        -in-tree
 
 TESTS = block coroutine create disjoint enter enter3 processor stack wait yield

src/CodeGen/CodeGenerator.cc

@@ -9 +9 @@
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Sat Oct 19 19:30:38 2019
-// Update Count     : 506
+// Last Modified By : Andrew Beach
+// Last Modified On : Thr May  2 10:47:00 2019
+// Update Count     : 497
 //
 #include "CodeGenerator.h"
@@ -198 +198 @@
                 // deleted decls should never be used, so don't print them
                 if ( objectDecl->isDeleted && options.genC ) return;
-
-                // gcc allows an empty declarator (no name) for bit-fields and C states: 6.7.2.1 Structure and union specifiers,
-                // point 4, page 113: If the (bit field) value is zero, the declaration shall have no declarator.  For anything
-                // else, the anonymous name refers to the anonymous object for plan9 inheritance.
-                if ( objectDecl->get_name().empty() && options.genC && ! objectDecl->get_bitfieldWidth() ) {
+                if (objectDecl->get_name().empty() && options.genC ) {
                         // only generate an anonymous name when generating C code, otherwise it clutters the output too much
                         static UniqueName name = { "__anonymous_object" };
                         objectDecl->set_name( name.newName() );
-                        // Stops unused parameter warnings.
-                        if ( options.anonymousUnused ) {
-                                objectDecl->attributes.push_back( new Attribute( "unused" ) );
-                        }
+            // Stops unused parameter warnings.
+            if ( options.anonymousUnused ) {
+                objectDecl->attributes.push_back( new Attribute( "unused" ) );
+            }
                 }
 

src/CodeGen/GenType.cc

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

src/ControlStruct/MLEMutator.cc

@@ -10 +10 @@
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Tue Oct 22 17:22:44 2019
-// Update Count     : 220
+// Last Modified On : Thu Mar  8 17:08:25 2018
+// Update Count     : 219
 //
 
@@ -313 +313 @@
         }
 
-        void MLEMutator::premutate( TryStmt * tryStmt ) {
-                // generate a label for breaking out of a labeled if
-                bool labeledBlock = !(tryStmt->get_labels().empty());
-                if ( labeledBlock ) {
-                        Label brkLabel = generator->newLabel("blockBreak", tryStmt);
-                        enclosingControlStructures.push_back( Entry( tryStmt, brkLabel ) );
-                        GuardAction( [this]() { enclosingControlStructures.pop_back(); } );
-                } // if
-        }
-
-        Statement * MLEMutator::postmutate( TryStmt * tryStmt ) {
-                bool labeledBlock = !(tryStmt->get_labels().empty());
-                if ( labeledBlock ) {
-                        if ( ! enclosingControlStructures.back().useBreakExit().empty() ) {
-                                set_breakLabel( enclosingControlStructures.back().useBreakExit() );
-                        } // if
-                } // if
-                return tryStmt;
-        }
-
         void MLEMutator::premutate( CaseStmt *caseStmt ) {
                 visit_children = false;

src/ControlStruct/MLEMutator.h

@@ -10 +10 @@
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Tue Oct 22 17:22:47 2019
-// Update Count     : 45
+// Last Modified On : Thu Mar  8 16:42:32 2018
+// Update Count     : 41
 //
 
@@ -47 +47 @@
                 void premutate( SwitchStmt *switchStmt );
                 Statement * postmutate( SwitchStmt *switchStmt );
-                void premutate( TryStmt *tryStmt );
-                Statement * postmutate( TryStmt *tryStmt );
 
                 Statement *mutateLoop( Statement *bodyLoop, Entry &e );
@@ -75 +73 @@
                         explicit Entry( SwitchStmt *stmt, Label breakExit, Label fallDefaultExit ) :
                                 stmt( stmt ), breakExit( breakExit ), fallDefaultExit( fallDefaultExit ) {}
-
-                        explicit Entry( TryStmt *stmt, Label breakExit ) :
-                                stmt( stmt ), breakExit( breakExit ) {}
 
                         bool operator==( const Statement *other ) { return stmt == other; }

src/GenPoly/Box.cc

@@ -837 +837 @@
                                         deref->args.push_back( new CastExpr( new VariableExpr( param ), new PointerType( Type::Qualifiers(), arg->get_type()->clone() ) ) );
                                         deref->result = arg->get_type()->clone();
+                                        deref->result->set_lvalue( true );
                                         return deref;
                                 } // if

src/GenPoly/Lvalue.cc

@@ -54 +54 @@
                                 delete ret->result;
                                 ret->result = base->clone();
+                                ret->result->set_lvalue( true );
                                 return ret;
                         } else {
@@ -166 +167 @@
                                 ReferenceType * result = strict_dynamic_cast< ReferenceType * >( appExpr->result );
                                 appExpr->result = result->base->clone();
+                                appExpr->result->set_lvalue( true );
                                 if ( ! inIntrinsic ) {
                                         // when not in an intrinsic function, add a cast to
@@ -434 +436 @@
                                 delete ret->result;
                                 ret->result = castExpr->result;
-                                assert( ret->get_lvalue() ); // ensure result is lvalue
+                                ret->result->set_lvalue( true ); // ensure result is lvalue
                                 castExpr->env = nullptr;
                                 castExpr->arg = nullptr;

src/Makefile.in

@@ -231 +231 @@
         SynTree/Initializer.$(OBJEXT) \
         SynTree/TypeSubstitution.$(OBJEXT) SynTree/Attribute.$(OBJEXT) \
-        SynTree/DeclReplacer.$(OBJEXT)
+        SynTree/DeclReplacer.$(OBJEXT) SynTree/TopLvalue.$(OBJEXT)
 am__objects_8 = CompilationState.$(OBJEXT) $(am__objects_1) \
         $(am__objects_2) Concurrency/Keywords.$(OBJEXT) \
@@ -411 +411 @@
 CCDEPMODE = @CCDEPMODE@
 CFACC = @CFACC@
-CFACC_INSTALL = @CFACC_INSTALL@
 CFACPP = @CFACPP@
 CFA_BACKEND_CC = @CFA_BACKEND_CC@
@@ -696 +695 @@
       SynTree/TypeSubstitution.cc \
       SynTree/Attribute.cc \
-      SynTree/DeclReplacer.cc
+      SynTree/DeclReplacer.cc \
+      SynTree/TopLvalue.cc
 
 
@@ -1025 +1025 @@
 SynTree/DeclReplacer.$(OBJEXT): SynTree/$(am__dirstamp) \
         SynTree/$(DEPDIR)/$(am__dirstamp)
+SynTree/TopLvalue.$(OBJEXT): SynTree/$(am__dirstamp) \
+        SynTree/$(DEPDIR)/$(am__dirstamp)
 Tuples/$(am__dirstamp):
         @$(MKDIR_P) Tuples
@@ -1335 +1337 @@
 @AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/ReferenceType.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/Statement.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/TopLvalue.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/TupleExpr.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/TupleType.Po@am__quote@

src/ResolvExpr/ConversionCost.cc

@@ -157 +157 @@
                         if ( typesCompatibleIgnoreQualifiers( src, destAsRef->base, indexer, env ) ) {
                                 PRINT( std::cerr << "converting compatible base type" << std::endl; )
+                                assert( src->get_lvalue() == srcIsLvalue );
                                 if ( srcIsLvalue ) {
                                         PRINT(

src/ResolvExpr/ResolveAssertions.cc

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

src/SymTab/Autogen.h

@@ -97 +97 @@
                         //   type->get_qualifiers() = Type::Qualifiers();
                         Type * castType = addCast->clone();
-                        castType->get_qualifiers() -= Type::Qualifiers( Type::Const | Type::Volatile | Type::Restrict | Type::Atomic );
+                        castType->get_qualifiers() -= Type::Qualifiers( Type::Lvalue | Type::Const | Type::Volatile | Type::Restrict | Type::Atomic );
                         // castType->set_lvalue( true ); // xxx - might not need this
                         dstParam = new CastExpr( dstParam, new ReferenceType( Type::Qualifiers(), castType ) );

src/SymTab/ManglerCommon.cc

@@ -88 +88 @@
                                 { Type::Atomic, "DA" }, // A is array, so need something unique for atmoic. For now, go with multiletter DA
                                 { Type::Mutex, "X" },
+                                { Type::Lvalue, "L" },
                         };
 

src/SymTab/Validate.cc

@@ -81 +81 @@
 #include "SynTree/Label.h"             // for operator==, Label
 #include "SynTree/Mutator.h"           // for Mutator
+#include "SynTree/TopLvalue.h"         // for assertTopLvalue, clearInnerLvalue
 #include "SynTree/Type.h"              // for Type, TypeInstType, EnumInstType
 #include "SynTree/TypeSubstitution.h"  // for TypeSubstitution
@@ -308 +309 @@
                 PassVisitor<FixQualifiedTypes> fixQual;
 
+                assertTopLvalue( translationUnit );
                 {
                         Stats::Heap::newPass("validate-A");
@@ -316 +318 @@
                         acceptAll( translationUnit, epc ); // must happen before VerifyCtorDtorAssign, because void return objects should not exist; before LinkReferenceToTypes_old because it is an indexer and needs correct types for mangling
                 }
+                assertTopLvalue( translationUnit );
                 {
                         Stats::Heap::newPass("validate-B");
                         Stats::Time::BlockGuard guard("validate-B");
+                        assertTopLvalue( translationUnit );
                         Stats::Time::TimeBlock("Link Reference To Types", [&]() {
                                 acceptAll( translationUnit, lrt ); // must happen before autogen, because sized flag needs to propagate to generated functions
                         });
+                        clearInnerLvalue( translationUnit );
+                        assertTopLvalue( translationUnit );
                         Stats::Time::TimeBlock("Fix Qualified Types", [&]() {
                                 mutateAll( translationUnit, fixQual ); // must happen after LinkReferenceToTypes_old, because aggregate members are accessed
                         });
+                        assertTopLvalue( translationUnit );
                         Stats::Time::TimeBlock("Hoist Structs", [&]() {
                                 HoistStruct::hoistStruct( translationUnit ); // must happen after EliminateTypedef, so that aggregate typedefs occur in the correct order
                         });
+                        assertTopLvalue( translationUnit );
                         Stats::Time::TimeBlock("Eliminate Typedefs", [&]() {
                                 EliminateTypedef::eliminateTypedef( translationUnit ); //
                         });
                 }
+                assertTopLvalue( translationUnit );
                 {
                         Stats::Heap::newPass("validate-C");
@@ -340 +349 @@
                         InitTweak::fixReturnStatements( translationUnit ); // must happen before autogen
                 }
+                assertTopLvalue( translationUnit );
                 {
                         Stats::Heap::newPass("validate-D");
                         Stats::Time::BlockGuard guard("validate-D");
+                        assertTopLvalue( translationUnit );
                         Stats::Time::TimeBlock("Apply Concurrent Keywords", [&]() {
                                 Concurrency::applyKeywords( translationUnit );
                         });
+                        clearInnerLvalue( translationUnit );
+                        assertTopLvalue( translationUnit );
                         Stats::Time::TimeBlock("Forall Pointer Decay", [&]() {
                                 acceptAll( translationUnit, fpd ); // must happen before autogenerateRoutines, after Concurrency::applyKeywords because uniqueIds must be set on declaration before resolution
                         });
+                        assertTopLvalue( translationUnit );
                         Stats::Time::TimeBlock("Hoist Control Declarations", [&]() {
                                 ControlStruct::hoistControlDecls( translationUnit );  // hoist initialization out of for statements; must happen before autogenerateRoutines
                         });
+                        assertTopLvalue( translationUnit );
                         Stats::Time::TimeBlock("Generate Autogen routines", [&]() {
                                 autogenerateRoutines( translationUnit ); // moved up, used to be below compoundLiteral - currently needs EnumAndPointerDecay_old
                         });
-                }
+                        clearInnerLvalue( translationUnit );
+                }
+                assertTopLvalue( translationUnit );
                 {
                         Stats::Heap::newPass("validate-E");
                         Stats::Time::BlockGuard guard("validate-E");
+                        assertTopLvalue( translationUnit );
                         Stats::Time::TimeBlock("Implement Mutex Func", [&]() {
                                 Concurrency::implementMutexFuncs( translationUnit );
                         });
+                        clearInnerLvalue( translationUnit );
+                        assertTopLvalue( translationUnit );
                         Stats::Time::TimeBlock("Implement Thread Start", [&]() {
                                 Concurrency::implementThreadStarter( translationUnit );
                         });
+                        assertTopLvalue( translationUnit );
                         Stats::Time::TimeBlock("Compound Literal", [&]() {
                                 mutateAll( translationUnit, compoundliteral );
                         });
+                        assertTopLvalue( translationUnit );
                         Stats::Time::TimeBlock("Resolve With Expressions", [&]() {
                                 ResolvExpr::resolveWithExprs( translationUnit ); // must happen before FixObjectType because user-code is resolved and may contain with variables
                         });
-                }
+                        clearInnerLvalue( translationUnit );
+                }
+                assertTopLvalue( translationUnit );
                 {
                         Stats::Heap::newPass("validate-F");
                         Stats::Time::BlockGuard guard("validate-F");
+                        assertTopLvalue( translationUnit );
                         Stats::Time::TimeBlock("Fix Object Type", [&]() {
                                 FixObjectType::fix( translationUnit );
                         });
+                        assertTopLvalue( translationUnit );
                         Stats::Time::TimeBlock("Array Length", [&]() {
                                 ArrayLength::computeLength( translationUnit );
                         });
+                        clearInnerLvalue( translationUnit );
+                        assertTopLvalue( translationUnit );
                         Stats::Time::TimeBlock("Find Special Declarations", [&]() {
                                 Validate::findSpecialDecls( translationUnit );
                         });
+                        assertTopLvalue( translationUnit );
                         Stats::Time::TimeBlock("Fix Label Address", [&]() {
                                 mutateAll( translationUnit, labelAddrFixer );
                         });
+                        assertTopLvalue( translationUnit );
                         Stats::Time::TimeBlock("Handle Attributes", [&]() {
                                 Validate::handleAttributes( translationUnit );
                         });
                 }
+                assertTopLvalue( translationUnit );
         }
 
@@ -1303 +1334 @@
         void FixObjectType::previsit( ObjectDecl * objDecl ) {
                 Type * new_type = ResolvExpr::resolveTypeof( objDecl->get_type(), indexer );
+                new_type->get_qualifiers() -= Type::Lvalue; // even if typeof is lvalue, variable can never have lvalue-qualified type
                 objDecl->set_type( new_type );
         }
@@ -1308 +1340 @@
         void FixObjectType::previsit( FunctionDecl * funcDecl ) {
                 Type * new_type = ResolvExpr::resolveTypeof( funcDecl->type, indexer );
+                new_type->get_qualifiers() -= Type::Lvalue; // even if typeof is lvalue, variable can never have lvalue-qualified type
                 funcDecl->set_type( new_type );
         }
@@ -1314 +1347 @@
                 if ( typeDecl->get_base() ) {
                         Type * new_type = ResolvExpr::resolveTypeof( typeDecl->get_base(), indexer );
+                        new_type->get_qualifiers() -= Type::Lvalue; // even if typeof is lvalue, variable can never have lvalue-qualified type
                         typeDecl->set_base( new_type );
                 } // if

src/SynTree/AddressExpr.cc

@@ -53 +53 @@
                         } // if
                 }
+                // result of & is never an lvalue
+                get_result()->set_lvalue( false );
         }
 }

src/SynTree/ApplicationExpr.cc

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

src/SynTree/ArrayType.cc

@@ -26 +26 @@
 ArrayType::ArrayType( const Type::Qualifiers &tq, Type *base, Expression *dimension, bool isVarLen, bool isStatic, const std::list< Attribute * > & attributes )
         : Type( tq, attributes ), base( base ), dimension( dimension ), isVarLen( isVarLen ), isStatic( isStatic ) {
+        base->set_lvalue( false );
 }
 

src/SynTree/CommaExpr.cc

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

src/SynTree/Expression.cc

@@ -19 +19 @@
 #include <iostream>                  // for ostream, operator<<, basic_ostream
 #include <list>                      // for list, _List_iterator, list<>::co...
-#include <set>                       // for set
 
 #include "Common/utility.h"          // for maybeClone, cloneAll, deleteAll
@@ -65 +64 @@
 
 bool Expression::get_lvalue() const {
+        assert( !result->get_lvalue() );
         return false;
 }
@@ -115 +115 @@
         assert( var->get_type() );
         Type * type = var->get_type()->clone();
+        type->set_lvalue( true );
 
         // xxx - doesn't quite work yet - get different alternatives with the same cost
@@ -124 +125 @@
         //      long long int value;
         //      if ( decl->valueOf( var, value ) ) {
-        //              type->set_lvalue( false ); // Would have to move to get_lvalue.
+        //              type->set_lvalue( false );
         //      }
         // }
@@ -139 +140 @@
 
 bool VariableExpr::get_lvalue() const {
-        // It isn't always an lvalue, but it is never an rvalue.
-        return true;
+        return result->get_lvalue();
 }
 
@@ -277 +277 @@
 
 bool CastExpr::get_lvalue() const {
-        // This is actually wrong by C, but it works with our current set-up.
-        return arg->get_lvalue();
+        return result->get_lvalue();
 }
 
@@ -361 +360 @@
 }
 
-bool UntypedMemberExpr::get_lvalue() const {
-        return aggregate->get_lvalue();
-}
-
 void UntypedMemberExpr::print( std::ostream & os, Indenter indent ) const {
         os << "Untyped Member Expression, with field: " << std::endl << indent+1;
@@ -383 +378 @@
         sub.apply( res );
         result = res;
+        result->set_lvalue( true );
         result->get_qualifiers() |= aggregate->result->get_qualifiers();
 }
@@ -396 +392 @@
 
 bool MemberExpr::get_lvalue() const {
-        // This is actually wrong by C, but it works with our current set-up.
+        assert( result->get_lvalue() );
         return true;
 }
@@ -431 +427 @@
                         // if references are still allowed in the AST, dereference returns a reference
                         ret->set_result( new ReferenceType( Type::Qualifiers(), ret->get_result() ) );
+                } else {
+                        // references have been removed, in which case dereference returns an lvalue of the base type.
+                        ret->result->set_lvalue( true );
                 }
         }
@@ -448 +447 @@
 
 bool UntypedExpr::get_lvalue() const {
-        // from src/GenPoly/Lvalue.cc: isIntrinsicReference
-        static std::set<std::string> lvalueFunctions = { "*?", "?[?]" };
-        std::string fname = InitTweak::getFunctionName( const_cast< UntypedExpr * >( this ) );
-        return lvalueFunctions.count(fname);
+        return result->get_lvalue();
 }
 
@@ -514 +510 @@
 
 bool ConditionalExpr::get_lvalue() const {
-        return false;
+        return result->get_lvalue();
 }
 
@@ -574 +570 @@
 
 bool ConstructorExpr::get_lvalue() const {
-        return false;
+        return result->get_lvalue();
 }
 
@@ -586 +582 @@
 CompoundLiteralExpr::CompoundLiteralExpr( Type * type, Initializer * initializer ) : initializer( initializer ) {
         assert( type && initializer );
+        type->set_lvalue( true );
         set_result( type );
 }
@@ -596 +593 @@
 
 bool CompoundLiteralExpr::get_lvalue() const {
+        assert( result->get_lvalue() );
         return true;
 }
@@ -650 +648 @@
 }
 bool StmtExpr::get_lvalue() const {
-        return false;
+        return result->get_lvalue();
 }
 void StmtExpr::print( std::ostream & os, Indenter indent ) const {

src/SynTree/Expression.h

@@ -275 +275 @@
         virtual ~UntypedMemberExpr();
 
-        bool get_lvalue() const final;
-
         Expression * get_member() const { return member; }
         void set_member( Expression * newValue ) { member = newValue; }

src/SynTree/TupleExpr.cc

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

src/SynTree/Type.cc

@@ -85 +85 @@
 const char * Type::FuncSpecifiersNames[] = { "inline", "_Noreturn", "fortran" };
 const char * Type::StorageClassesNames[] = { "extern", "static", "auto", "register", "_Thread_local" };
-const char * Type::QualifiersNames[] = { "const", "restrict", "volatile", "mutex", "_Atomic" };
+const char * Type::QualifiersNames[] = { "const", "restrict", "volatile", "lvalue", "mutex", "_Atomic" };
 
 Type * Type::stripDeclarator() {

src/SynTree/Type.h

@@ -102 +102 @@
         }; // StorageClasses
 
-        enum { Const = 1 << 0, Restrict = 1 << 1, Volatile = 1 << 2, Mutex = 1 << 3, Atomic = 1 << 4, NumTypeQualifier = 5 };
+        enum { Const = 1 << 0, Restrict = 1 << 1, Volatile = 1 << 2, Lvalue = 1 << 3, Mutex = 1 << 4, Atomic = 1 << 5, NumTypeQualifier = 6 };
         static const char * QualifiersNames[];
         union Qualifiers {
-                enum { Mask = ~Restrict };
+                enum { Mask = ~(Restrict | Lvalue) };
                 unsigned int val;
                 struct {
@@ -111 +111 @@
                         bool is_restrict : 1;
                         bool is_volatile : 1;
+                        bool is_lvalue : 1;
                         bool is_mutex : 1;
                         bool is_atomic : 1;
@@ -152 +153 @@
         bool get_volatile() const { return tq.is_volatile; }
         bool get_restrict() const { return tq.is_restrict; }
+        bool get_lvalue() const { return tq.is_lvalue; }
         bool get_mutex() const { return tq.is_mutex; }
         bool get_atomic() const { return tq.is_atomic; }
@@ -157 +159 @@
         void set_volatile( bool newValue ) { tq.is_volatile = newValue; }
         void set_restrict( bool newValue ) { tq.is_restrict = newValue; }
+        void set_lvalue( bool newValue ) { tq.is_lvalue = newValue; }
         void set_mutex( bool newValue ) { tq.is_mutex = newValue; }
         void set_atomic( bool newValue ) { tq.is_atomic = newValue; }

src/SynTree/module.mk

@@ -49 +49 @@
       SynTree/TypeSubstitution.cc \
       SynTree/Attribute.cc \
-      SynTree/DeclReplacer.cc
+      SynTree/DeclReplacer.cc \
+      SynTree/TopLvalue.cc
 
 SRC += $(SRC_SYNTREE)

src/Tuples/TupleExpansion.cc

@@ -304 +304 @@
                 // produce the TupleType which aggregates the types of the exprs
                 std::list< Type * > types;
-                Type::Qualifiers qualifiers( Type::Const | Type::Volatile | Type::Restrict | Type::Atomic | Type::Mutex );
+                Type::Qualifiers qualifiers( Type::Const | Type::Volatile | Type::Restrict | Type::Lvalue | Type::Atomic | Type::Mutex );
                 for ( Expression * expr : exprs ) {
                         assert( expr->get_result() );

src/main.cc

@@ -59 +59 @@
 #include "ResolvExpr/Resolver.h"            // for resolve
 #include "SymTab/Validate.h"                // for validate
+#include "SynTree/TopLvalue.h"              // for assertTopLvalue, clearInn...
 #include "SynTree/Declaration.h"            // for Declaration
 #include "SynTree/Visitor.h"                // for acceptAll
@@ -258 +259 @@
                 Stats::Time::StopBlock();
 
+                //std::cerr << "Post-Parse Check" << std::endl;
+                clearInnerLvalue( translationUnit );
+                assertTopLvalue( translationUnit );
+
                 // add the assignment statement after the initialization of a type parameter
                 PASS( "Validate", SymTab::validate( translationUnit, symtabp ) );
@@ -276 +281 @@
                 } // if
 
+                assertTopLvalue( translationUnit );
                 PASS( "Fix Labels", ControlStruct::fixLabels( translationUnit ) );
+                assertTopLvalue( translationUnit );
                 PASS( "Fix Names", CodeGen::fixNames( translationUnit ) );
+                assertTopLvalue( translationUnit );
                 PASS( "Gen Init", InitTweak::genInit( translationUnit ) );
+                assertTopLvalue( translationUnit );
                 PASS( "Expand Member Tuples" , Tuples::expandMemberTuples( translationUnit ) );
+                assertTopLvalue( translationUnit );
                 if ( libcfap ) {
                         // generate the bodies of cfa library functions
@@ -303 +313 @@
                 } // if
 
+                assertTopLvalue( translationUnit );
+
                 PASS( "Resolve", ResolvExpr::resolve( translationUnit ) );
                 if ( exprp ) {
@@ -309 +321 @@
                 } // if
 
+                clearInnerLvalue( translationUnit );
+                assertTopLvalue( translationUnit );
+
                 // fix ObjectDecl - replaces ConstructorInit nodes
                 PASS( "Fix Init", InitTweak::fix( translationUnit, buildingLibrary() ) );
+                clearInnerLvalue( translationUnit );
+                assertTopLvalue( translationUnit );
                 if ( ctorinitp ) {
                         dump ( translationUnit );
@@ -317 +334 @@
 
                 PASS( "Expand Unique Expr", Tuples::expandUniqueExpr( translationUnit ) ); // xxx - is this the right place for this? want to expand ASAP so tha, sequent passes don't need to worry about double-visiting a unique expr - needs to go after InitTweak::fix so that copy constructed return declarations are reused
+                assertTopLvalue( translationUnit );
 
                 PASS( "Translate EHM" , ControlStruct::translateEHM( translationUnit ) );
+                assertTopLvalue( translationUnit );
 
                 PASS( "Gen Waitfor" , Concurrency::generateWaitFor( translationUnit ) );
+                clearInnerLvalue( translationUnit );
+                assertTopLvalue( translationUnit );
 
                 PASS( "Convert Specializations",  GenPoly::convertSpecializations( translationUnit ) ); // needs to happen before tuple types are expanded
+                clearInnerLvalue( translationUnit );
+                assertTopLvalue( translationUnit );
 
                 PASS( "Expand Tuples", Tuples::expandTuples( translationUnit ) ); // xxx - is this the right place for this?
+                assertTopLvalue( translationUnit );
 
                 if ( tuplep ) {
@@ -332 +356 @@
 
                 PASS( "Virtual Expand Casts", Virtual::expandCasts( translationUnit ) ); // Must come after translateEHM
+                assertTopLvalue( translationUnit );
 
                 PASS( "Instantiate Generics", GenPoly::instantiateGeneric( translationUnit ) );
@@ -338 +363 @@
                         return EXIT_SUCCESS;
                 } // if
-
+                clearInnerLvalue( translationUnit );
+                assertTopLvalue( translationUnit );
                 PASS( "Convert L-Value", GenPoly::convertLvalue( translationUnit ) );
+                clearInnerLvalue( translationUnit );
+                assertTopLvalue( translationUnit );
 
                 if ( bboxp ) {
@@ -346 +374 @@
                 } // if
                 PASS( "Box", GenPoly::box( translationUnit ) );
+                clearInnerLvalue( translationUnit );
+                assertTopLvalue( translationUnit );
 
                 if ( bcodegenp ) {
@@ -357 +387 @@
 
                 CodeTools::fillLocations( translationUnit );
+                assertTopLvalue( translationUnit );
                 PASS( "Code Gen", CodeGen::generate( translationUnit, *output, ! genproto, prettycodegenp, true, linemarks ) );
 

tests/.expect/alloc-ERROR.txt

@@ -1 @@
-alloc.cfa:311:1 error: No reasonable alternatives for expression Applying untyped:
+alloc.cfa:265:1 error: No reasonable alternatives for expression Applying untyped:
   Name: ?=?
 ...to:
@@ -19 +19 @@
 
 
-alloc.cfa:312:1 error: No reasonable alternatives for expression Applying untyped:
+alloc.cfa:266:1 error: No reasonable alternatives for expression Applying untyped:
   Name: ?=?
 ...to:
@@ -39 +39 @@
 
 
-alloc.cfa:313:1 error: No reasonable alternatives for expression Applying untyped:
+alloc.cfa:267:1 error: No reasonable alternatives for expression Applying untyped:
   Name: ?=?
 ...to:
@@ -50 +50 @@
 
 
-alloc.cfa:314:1 error: No reasonable alternatives for expression Applying untyped:
+alloc.cfa:268:1 error: No reasonable alternatives for expression Applying untyped:
   Name: ?=?
 ...to:

tests/.expect/alloc.txt

@@ -2 +2 @@
 CFA malloc 0xdeadbeef
 CFA alloc 0xdeadbeef
-CFA array alloc, fill 0xde
-CFA alloc, fill dededede
-CFA alloc, fill 3
+CFA alloc, fill ffffffff
 
 C   array calloc, fill 0
@@ -12 +10 @@
 CFA array alloc, no fill
 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 
-CFA array alloc, fill 0xde
-0xdededede 0xdededede 0xdededede 0xdededede 0xdededede 0xdededede 0xdededede 0xdededede 0xdededede 0xdededede 0xdededede 0xdededede 0xdededede 0xdededede 0xdededede 0xdededede 0xdededede 0xdededede 0xdededede 0xdededede 
-CFA array alloc, fill 0xef
-0xefefefef 0xefefefef 0xefefefef 0xefefefef 0xefefefef 0xefefefef 0xefefefef 0xefefefef 0xefefefef 0xefefefef 0xefefefef 0xefefefef 0xefefefef 0xefefefef 0xefefefef 0xefefefef 0xefefefef 0xefefefef 0xefefefef 0xefefefef 
-CFA array alloc, fill from array
-0xefefefef 0xefefefef, 0xefefefef 0xefefefef, 0xefefefef 0xefefefef, 0xefefefef 0xefefefef, 0xefefefef 0xefefefef, 0xefefefef 0xefefefef, 0xefefefef 0xefefefef, 0xefefefef 0xefefefef, 0xefefefef 0xefefefef, 0xefefefef 0xefefefef, 0xefefefef 0xefefefef, 0xefefefef 0xefefefef, 0xefefefef 0xefefefef, 0xefefefef 0xefefefef, 0xefefefef 0xefefefef, 0xefefefef 0xefefefef, 0xefefefef 0xefefefef, 0xefefefef 0xefefefef, 0xefefefef 0xefefefef, 0xefefefef 0xefefefef, 
+CFA array alloc, fill 0xff
+0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 
 
-C realloc
-0xefefefef 0xefefefef 0xefefefef 0xefefefef 0xefefefef 0xefefefef 0xefefefef 0xefefefef 0xefefefef 0xefefefef 
+C   realloc
+0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 
 CFA realloc
-0xefefefef 0xefefefef 0xefefefef 0xefefefef 0xefefefef 0xefefefef 0xefefefef 0xefefefef 0xefefefef 0xefefefef 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 
+0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 
 
-CFA resize array alloc
+CFA resize alloc
 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 
 CFA resize array alloc
@@ -31 +25 @@
 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 
 CFA resize array alloc, fill
-0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0xdededede 0xdededede 0xdededede 0xdededede 0xdededede 0xdededede 0xdededede 0xdededede 0xdededede 0xdededede 
+0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 
 CFA resize array alloc, fill
-0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 
+0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 
 CFA resize array alloc, fill
-0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0xdededede 0xdededede 0xdededede 0xdededede 0xdededede 0xdededede 0xdededede 0xdededede 0xdededede 0xdededede 
+0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 
 
 C   memalign 42 42.5
@@ -41 +35 @@
 CFA posix_memalign 42 42.5
 CFA posix_memalign 42 42.5
-CFA alloc_align 42 42.5
-CFA alloc_align 42 42.5
-CFA alloc_align fill 0xdededede -0x1.ededededededep+494
-CFA alloc_align fill 42 42.5
-CFA alloc_align 42 42.5
+CFA aligned_alloc 42 42.5
+CFA align_alloc 42 42.5
+CFA align_alloc fill 0xffffffff -nan
 
-CFA array alloc_align
+CFA array align_alloc
 42 42.5, 42 42.5, 42 42.5, 42 42.5, 42 42.5, 42 42.5, 42 42.5, 42 42.5, 42 42.5, 42 42.5, 
-CFA array alloc_align, fill
-0xdededede -0x1.ededededededep+494, 0xdededede -0x1.ededededededep+494, 0xdededede -0x1.ededededededep+494, 0xdededede -0x1.ededededededep+494, 0xdededede -0x1.ededededededep+494, 0xdededede -0x1.ededededededep+494, 0xdededede -0x1.ededededededep+494, 0xdededede -0x1.ededededededep+494, 0xdededede -0x1.ededededededep+494, 0xdededede -0x1.ededededededep+494, 
-CFA array alloc_align, fill
-42 42.5, 42 42.5, 42 42.5, 42 42.5, 42 42.5, 42 42.5, 42 42.5, 42 42.5, 42 42.5, 42 42.5, 
-CFA array alloc_align, fill array
-42 42.5, 42 42.5, 42 42.5, 42 42.5, 42 42.5, 42 42.5, 42 42.5, 42 42.5, 42 42.5, 42 42.5, 
-CFA realloc array alloc_align
-42 42.5, 42 42.5, 42 42.5, 42 42.5, 42 42.5, 42 42.5, 42 42.5, 42 42.5, 42 42.5, 42 42.5, 
+CFA array align_alloc, fill
+0xffffffff -nan, 0xffffffff -nan, 0xffffffff -nan, 0xffffffff -nan, 0xffffffff -nan, 0xffffffff -nan, 0xffffffff -nan, 0xffffffff -nan, 0xffffffff -nan, 0xffffffff -nan, 
 
-CFA memset 0xdededede -0x1.ededededededep+494
-CFA memcpy 0xdededede -0x1.ededededededep+494
+CFA memset 0xffffffff -nan
+CFA memcpy 0xffffffff -nan
 
 CFA array memset
-0xdededede -0x1.ededededededep+494, 0xdededede -0x1.ededededededep+494, 0xdededede -0x1.ededededededep+494, 0xdededede -0x1.ededededededep+494, 0xdededede -0x1.ededededededep+494, 0xdededede -0x1.ededededededep+494, 0xdededede -0x1.ededededededep+494, 0xdededede -0x1.ededededededep+494, 0xdededede -0x1.ededededededep+494, 0xdededede -0x1.ededededededep+494, 
+0xffffffff -nan, 0xffffffff -nan, 0xffffffff -nan, 0xffffffff -nan, 0xffffffff -nan, 0xffffffff -nan, 0xffffffff -nan, 0xffffffff -nan, 0xffffffff -nan, 0xffffffff -nan, 
 CFA array memcpy
-0xdededede -0x1.ededededededep+494, 0xdededede -0x1.ededededededep+494, 0xdededede -0x1.ededededededep+494, 0xdededede -0x1.ededededededep+494, 0xdededede -0x1.ededededededep+494, 0xdededede -0x1.ededededededep+494, 0xdededede -0x1.ededededededep+494, 0xdededede -0x1.ededededededep+494, 0xdededede -0x1.ededededededep+494, 0xdededede -0x1.ededededededep+494, 
+0xffffffff -nan, 0xffffffff -nan, 0xffffffff -nan, 0xffffffff -nan, 0xffffffff -nan, 0xffffffff -nan, 0xffffffff -nan, 0xffffffff -nan, 0xffffffff -nan, 0xffffffff -nan, 
 
 CFA new initialize

tests/.expect/attributes.x64.txt

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

tests/.expect/attributes.x86.txt

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

tests/Makefile.am

@@ -24 +24 @@
 archiveerrors=
 
+INSTALL_FLAGS=-in-tree
 DEBUG_FLAGS=-debug -O0
 
@@ -42 +43 @@
         -DIN_DIR="${abs_srcdir}/.in/"
 
-# get the desired cfa to test
-TARGET_CFA = $(if $(filter $(installed),yes), @CFACC_INSTALL@, @CFACC@)
-
 # adjust CC to current flags
-CC = $(if $(ifeq $(DISTCC_CFA_PATH),yes),distcc $(DISTCC_CFA_PATH),$(TARGET_CFA) ${DEBUG_FLAGS} ${ARCH_FLAGS})
+CC = $(if $(DISTCC_CFA_PATH),distcc $(DISTCC_CFA_PATH) -dist-tree -in-tree,@CFACC@ ${DEBUG_FLAGS} ${INSTALL_FLAGS} ${ARCH_FLAGS})
 CFACC = $(CC)
 
@@ -53 +51 @@
 
 # adjusted CC but without the actual distcc call
-CFACCLOCAL = $(if $(DISTCC_CFA_PATH),$(DISTCC_CFA_PATH),$(TARGET_CFA) ${DEBUG_FLAGS} ${ARCH_FLAGS})
+CFACCLOCAL = $(if $(DISTCC_CFA_PATH),$(DISTCC_CFA_PATH) -dist-tree -in-tree,@CFACC@ ${DEBUG_FLAGS} ${INSTALL_FLAGS} ${ARCH_FLAGS})
 
 PRETTY_PATH=mkdir -p $(dir $(abspath ${@})) && cd ${srcdir} &&

tests/Makefile.in

@@ -214 +214 @@
 
 # adjust CC to current flags
-CC = $(if $(ifeq $(DISTCC_CFA_PATH),yes),distcc $(DISTCC_CFA_PATH),$(TARGET_CFA) ${DEBUG_FLAGS} ${ARCH_FLAGS})
+CC = $(if $(DISTCC_CFA_PATH),distcc $(DISTCC_CFA_PATH) -dist-tree -in-tree,@CFACC@ ${DEBUG_FLAGS} ${INSTALL_FLAGS} ${ARCH_FLAGS})
 CCAS = @CCAS@
 CCASDEPMODE = @CCASDEPMODE@
@@ -220 +220 @@
 CCDEPMODE = @CCDEPMODE@
 CFACC = $(CC)
-CFACC_INSTALL = @CFACC_INSTALL@
 CFACPP = @CFACPP@
 CFA_BACKEND_CC = @CFA_BACKEND_CC@
@@ -382 +381 @@
 installed = no
 archiveerrors = 
+INSTALL_FLAGS = -in-tree
 DEBUG_FLAGS = -debug -O0
 quick_test = avl_test operators numericConstants expression enum array typeof cast raii/dtor-early-exit raii/init_once attributes
@@ -398 +398 @@
 
 
-# get the desired cfa to test
-TARGET_CFA = $(if $(filter $(installed),yes), @CFACC_INSTALL@, @CFACC@)
-
 # get local binary for depedencies
 CFACCBIN = @CFACC@
 
 # adjusted CC but without the actual distcc call
-CFACCLOCAL = $(if $(DISTCC_CFA_PATH),$(DISTCC_CFA_PATH),$(TARGET_CFA) ${DEBUG_FLAGS} ${ARCH_FLAGS})
+CFACCLOCAL = $(if $(DISTCC_CFA_PATH),$(DISTCC_CFA_PATH) -dist-tree -in-tree,@CFACC@ ${DEBUG_FLAGS} ${INSTALL_FLAGS} ${ARCH_FLAGS})
 PRETTY_PATH = mkdir -p $(dir $(abspath ${@})) && cd ${srcdir} &&
 avl_test_SOURCES = avltree/avl_test.cfa avltree/avl0.cfa avltree/avl1.cfa avltree/avl2.cfa avltree/avl3.cfa avltree/avl4.cfa avltree/avl-private.cfa

tests/alloc.cfa

@@ -10 +10 @@
 // Created On       : Wed Feb  3 07:56:22 2016
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sun Oct 20 21:45:21 2019
-// Update Count     : 391
+// Last Modified On : Tue Nov  6 17:50:52 2018
+// Update Count     : 339
 //
 
@@ -19 +19 @@
 #include <stdlib.h>                                                                             // posix_memalign
 #include <fstream.hfa>
-#include <stdlib.hfa>                                                                   // access C malloc, realloc
+#include <stdlib.hfa>                                                                           // access C malloc, realloc
 
 int * foo( int * p, int c ) { return p; }
@@ -27 +27 @@
 int main( void ) {
         size_t dim = 10;
-        char fill = '\xde';
-        int * p, * p1;
+        char fill = '\xff';
+        int * p;
 
         // allocation, non-array types
 
+        // int & r = malloc();
+        // r = 0xdeadbeef;
+        // printf( "C   malloc %#x\n", r );
+        // free( &r );
+
         p = (int *)malloc( sizeof(*p) );                                        // C malloc, type unsafe
         *p = 0xdeadbeef;
@@ -47 +52 @@
         free( p );
 
-        p = alloc_set( fill );                                                          // CFA alloc, fill
-        printf( "CFA array alloc, fill %#hhx\n", fill );
+        p = alloc( fill );                                  // CFA alloc, fill
         printf( "CFA alloc, fill %08x\n", *p );
-        free( p );
-
-        p = alloc_set( 3 );                                                                     // CFA alloc, fill
-        printf( "CFA alloc, fill %d\n", *p );
         free( p );
 
@@ -79 +79 @@
         free( p );
 
-        p = alloc_set( 2 * dim, fill );                                         // CFA array alloc, fill
+        p = alloc( 2 * dim, fill );                         // CFA array alloc, fill
         printf( "CFA array alloc, fill %#hhx\n", fill );
         for ( i; 2 * dim ) { printf( "%#x ", p[i] ); }
         printf( "\n" );
-        free( p );
-
-        p = alloc_set( 2 * dim, 0xdeadbeef );                           // CFA array alloc, fill
-        printf( "CFA array alloc, fill %#hhx\n", 0xdeadbeef );
-        for ( i; 2 * dim ) { printf( "%#x ", p[i] ); }
-        printf( "\n" );
         // do not free
 
-        p1 = alloc_set( 2 * dim, p );                                           // CFA array alloc, fill
-        printf( "CFA array alloc, fill from array\n" );
-        for ( i; 2 * dim ) { printf( "%#x %#x, ", p[i], p1[i] ); }
-        free( p1 );
-        printf( "\n" );
-
 
         // resize, non-array types
@@ -102 +90 @@
 
         p = (int *)realloc( p, dim * sizeof(*p) );                      // C realloc
-        printf( "C realloc\n" );
-        for ( i; dim ) { printf( "%#x ", p[i] ); }
-        printf( "\n" );
-        // do not free
+        for ( i; dim ) { p[i] = 0xdeadbeef; }
+        printf( "C   realloc\n" );
+        for ( i; dim ) { printf( "%#x ", p[i] ); }
+        printf( "\n" );
 
         p = realloc( p, 2 * dim * sizeof(*p) );             // CFA realloc
@@ -120 +108 @@
         p = alloc( p, dim );                                // CFA resize array alloc
         for ( i; dim ) { p[i] = 0xdeadbeef; }
-        printf( "CFA resize array alloc\n" );
-        for ( i; dim ) { printf( "%#x ", p[i] ); }
-        printf( "\n" );
-        // do not free
+        printf( "CFA resize alloc\n" );
+        for ( i; dim ) { printf( "%#x ", p[i] ); }
+        printf( "\n" );
 
         p = alloc( p, 2 * dim );                            // CFA resize array alloc
@@ -130 +117 @@
         for ( i; 2 * dim ) { printf( "%#x ", p[i] ); }
         printf( "\n" );
-        // do not free
-
-        p = alloc( p, dim );                                // CFA resize array alloc
+
+        p = alloc( p, dim );                                // CFA array alloc
         printf( "CFA resize array alloc\n" );
         for ( i; dim ) { printf( "%#x ", p[i] ); }
         printf( "\n" );
-        // do not free
-
-        p = alloc_set( p, 3 * dim, fill );                                      // CFA resize array alloc, fill
+
+        free( p );
+        p = 0;
+
+        p = alloc( p, dim, fill );                          // CFA array alloc, fill
         printf( "CFA resize array alloc, fill\n" );
-        for ( i; 3 * dim ) { printf( "%#x ", p[i] ); }
-        printf( "\n" );
-        // do not free
-
-        p = alloc_set( p, dim, fill );                                          // CFA resize array alloc, fill
+        for ( i; dim ) { printf( "%#x ", p[i] ); }
+        printf( "\n" );
+
+        p = alloc( p, 2 * dim, fill );                      // CFA array alloc, fill
         printf( "CFA resize array alloc, fill\n" );
-        for ( i; dim ) { printf( "%#x ", p[i] ); }
-        printf( "\n" );
-        // do not free
-
-        p = alloc_set( p, 3 * dim, fill );                                      // CFA resize array alloc, fill
+        for ( i; 2 * dim ) { printf( "%#x ", p[i] ); }
+        printf( "\n" );
+
+        p = alloc( p, dim, fill );                          // CFA array alloc, fill
         printf( "CFA resize array alloc, fill\n" );
-        for ( i; 3 * dim ) { printf( "%#x ", p[i] );; }
+        for ( i; dim ) { printf( "%#x ", p[i] );; }
         printf( "\n" );
         free( p );
@@ -186 +172 @@
         free( stp );
 
-        stp = &(*alloc_align( Alignment)){ 42, 42.5 };          // CFA alloc_align
-        assert( (uintptr_t)stp % Alignment == 0 );
-        printf( "CFA alloc_align %d %g\n", stp->x, stp->y );
-        free( stp );
-
-        stp = &(*alloc_align( Alignment )){ 42, 42.5 };         // CFA alloc_align
-        assert( (uintptr_t)stp % Alignment == 0 );
-        printf( "CFA alloc_align %d %g\n", stp->x, stp->y );
-        free( stp );
-
-        stp = alloc_align_set( Alignment, fill );                       // CFA memalign, fill
-        assert( (uintptr_t)stp % Alignment == 0 );
-        printf( "CFA alloc_align fill %#x %a\n", stp->x, stp->y );
-        free( stp );
-
-        stp = alloc_align_set( Alignment, (Struct){ 42, 42.5 } ); // CFA memalign, fill
-        assert( (uintptr_t)stp % Alignment == 0 );
-        printf( "CFA alloc_align fill %d %g\n", stp->x, stp->y );
-        // do not free
-
-        stp = &(*alloc_align( stp, 4096 )){ 42, 42.5 };         // CFA realign
-        assert( (uintptr_t)stp % 4096 == 0 );
-        printf( "CFA alloc_align %d %g\n", stp->x, stp->y );
+        stp = &(*aligned_alloc( Alignment )){ 42, 42.5 };     // CFA aligned_alloc
+        assert( (uintptr_t)stp % Alignment == 0 );
+        printf( "CFA aligned_alloc %d %g\n", stp->x, stp->y );
+        free( stp );
+
+        stp = &(*align_alloc( Alignment )){ 42, 42.5 };       // CFA align_alloc
+        assert( (uintptr_t)stp % Alignment == 0 );
+        printf( "CFA align_alloc %d %g\n", stp->x, stp->y );
+        free( stp );
+
+        stp = align_alloc( Alignment, fill );               // CFA memalign, fill
+        assert( (uintptr_t)stp % Alignment == 0 );
+        printf( "CFA align_alloc fill %#x %a\n", stp->x, stp->y );
         free( stp );
 
@@ -215 +191 @@
         printf( "\n" );
 
-        stp = alloc_align( Alignment, dim );                // CFA array memalign
+        stp = align_alloc( Alignment, dim );                // CFA array memalign
         assert( (uintptr_t)stp % Alignment == 0 );
         for ( i; dim ) { stp[i] = (Struct){ 42, 42.5 }; }
-        printf( "CFA array alloc_align\n" );
+        printf( "CFA array align_alloc\n" );
         for ( i; dim ) { printf( "%d %g, ", stp[i].x, stp[i].y ); }
         printf( "\n" );
         free( stp );
 
-        stp = alloc_align_set( Alignment, dim, fill );          // CFA array memalign, fill
-        assert( (uintptr_t)stp % Alignment == 0 );
-        printf( "CFA array alloc_align, fill\n" );
+        stp = align_alloc( Alignment, dim, fill );          // CFA array memalign, fill
+        assert( (uintptr_t)stp % Alignment == 0 );
+        printf( "CFA array align_alloc, fill\n" );
         for ( i; dim ) { printf( "%#x %a, ", stp[i].x, stp[i].y ); }
-        printf( "\n" );
-        free( stp );
-
-        stp = alloc_align_set( Alignment, dim, (Struct){ 42, 42.5 } ); // CFA array memalign, fill
-        assert( (uintptr_t)stp % Alignment == 0 );
-        printf( "CFA array alloc_align, fill\n" );
-        for ( i; dim ) { printf( "%d %g, ", stp[i].x, stp[i].y ); }
-        printf( "\n" );
-        // do not free
-
-        stp1 = alloc_align_set( Alignment, dim, stp );          // CFA array memalign, fill
-        assert( (uintptr_t)stp % Alignment == 0 );
-        printf( "CFA array alloc_align, fill array\n" );
-        for ( i; dim ) { printf( "%d %g, ", stp1[i].x, stp1[i].y ); }
-        printf( "\n" );
-        free( stp1 );
-
-        stp = alloc_align( stp, 4096, dim );                            // CFA aligned realloc array
-        assert( (uintptr_t)stp % 4096 == 0 );
-        for ( i; dim ) { stp[i] = (Struct){ 42, 42.5 }; }
-        printf( "CFA realloc array alloc_align\n" );
-        for ( i; dim ) { printf( "%d %g, ", stp[i].x, stp[i].y ); }
         printf( "\n" );
         free( stp );

tests/concurrent/examples/quickSort.cfa

@@ -11 +11 @@
 // Created On       : Wed Dec  6 12:15:52 2017
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Oct 10 13:58:18 2019
-// Update Count     : 176
+// Last Modified On : Fri Jun 21 08:27:45 2019
+// Update Count     : 172
 //
 
@@ -66 +66 @@
                         if ( depth > 0 ) {
                                 depth -= 1;
-                                Quicksort lqs = { values, low, right, depth }; // concurrently sort lower half
-                                Quicksort rqs = { values, left, high, depth }; // concurrently sort upper half
-                                // Quicksort lqs = { values, low, right, depth }; // concurrently sort lower half
-                                // sort( values, left, high, depth );           // concurrently sort upper half
+                                Quicksort rqs = { values, low, right, depth }; // concurrently sort upper half
+                                //Quicksort lqs( values, left, high, depth ); // concurrently sort lower half
+                                sort( values, left, high, depth );              // concurrently sort lower half
                         } else {
                                 sort( values, low, right, 0 );                  // sequentially sort lower half
@@ -163 +162 @@
                 processor processors[ (1 << depth) - 1 ] __attribute__(( unused )); // create 2^depth-1 kernel threads
 
-                int * values = alloc( size );                                   // values to be sorted, too large to put on stack
-                for ( counter; size ) {                                                 // generate unsorted numbers
+                int * values = alloc( size );                           // values to be sorted, too large to put on stack
+                for ( counter; size ) {                                         // generate unsorted numbers
                         values[counter] = size - counter;                       // descending values
-                } // for
-                for ( int i = 0; i < 200; i +=1 ) {                             // random shuffle a few values
-                        swap( values[rand() % size], values[rand() % size] );
                 } // for
                 {
@@ -182 +178 @@
 } // main
 
-// for depth in 0 1 2 3 4 5 ; do echo "sort 500000000 values with ${depth} depth" ; time -f "%Uu %Ss %E %Mkb" a.out -t 500000000 ${depth} ; done
-
 // Local Variables: //
 // tab-width: 4 //

tests/labelledExit.cfa

@@ -10 +10 @@
 // Created On       : Wed Aug 10 07:29:39 2016
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Oct 25 17:41:51 2019
-// Update Count     : 7
+// Last Modified On : Tue Nov  6 17:57:42 2018
+// Update Count     : 4
 // 
 
@@ -136 +136 @@
         }
 
-        // all nested control options, labelled exits
-
-  Comp: {
-          Try: try {
-                  For: for ( ;; ) {
-                          While: while ( true ) {
-                                  Do: do {
-                                          If: if ( true ) {
-                                                  Switch2: switch ( 3 ) {
-                                                          case 3:
-                                                                break Try;
-                                                                break Comp;
-                                                                break For;              continue For;
-                                                                break While;    continue While;
-                                                                break Do;               continue Do;
-                                                                break If;
-                                                                break Switch2;
-                                                        } // switch
-                                                } // if
-                                        } while ( true );
-                                } // while
-                        } // for
-                } finally {} // always executed
-        } // compound
-
         // computed goto
         // {

tests/pybin/settings.py

@@ -96 +96 @@
                         distribute = False
 
-                self.string = "installed" if value else "in tree"
-                self.flags  = """installed=%s""" % ("yes" if value else "no")
+                self.string = "installed" if value else "in-tree"
+                self.flags  = """INSTALL_FLAGS=%s""" % ("" if value else "-in-tree")
 
 class Timeouts:

tests/pybin/tools.py

@@ -343 +343 @@
         # make a directory for this test
         # mkdir makes the parent directory only so add a dummy
-        mkdir(os.path.join(dst, name ))
+        mkdir(os.path.join(dst, "dir"))
 
         # moves the files

tools/Makefile.in

@@ -208 +208 @@
 CCDEPMODE = @CCDEPMODE@
 CFACC = @CFACC@
-CFACC_INSTALL = @CFACC_INSTALL@
 CFACPP = @CFACPP@
 CFA_BACKEND_CC = @CFA_BACKEND_CC@

tools/prettyprinter/Makefile.in

@@ -237 +237 @@
 CCDEPMODE = @CCDEPMODE@
 CFACC = @CFACC@
-CFACC_INSTALL = @CFACC_INSTALL@
 CFACPP = @CFACPP@
 CFA_BACKEND_CC = @CFA_BACKEND_CC@