Diff [0720e0491a93fec9fc95f4daaaa1652d4955d613:3d4b23fa9ef416e3543e652102009137f340d4e5] for / – Cforall

.gitignore

r0720e049	r3d4b23fa
24	24	lib
25	25	include
26		~~share~~
27	26
28	27	# src executables, for lib and bin

Makefile.am

r0720e049	r3d4b23fa
21	21
22	22	MAINTAINERCLEANFILES = lib/* bin/* src/examples/.deps/* src/tests/.deps/* src/tests/.out/*
23
24		~~man1_MANS = doc/man/cfa.1~~

Makefile.in

-              r0720e049
+              r3d4b23fa
     *) (install-info --version) >/dev/null 2>&1;; \
   esac
-am__vpath_adj_setup = srcdirstrip=`echo "$(srcdir)" | sed 's|.|.|g'`;
-am__vpath_adj = case $$p in \
-    $(srcdir)/*) f=`echo "$$p" | sed "s|^$$srcdirstrip/||"`;; \
-    *) f=$$p;; \
-  esac;
-am__strip_dir = f=`echo $$p | sed -e 's|^.*/||'`;
-am__install_max = 40
-am__nobase_strip_setup = \
-  srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*|]/\\\\&/g'`
-am__nobase_strip = \
-  for p in $$list; do echo "$$p"; done | sed -e "s|$$srcdirstrip/||"
-am__nobase_list = $(am__nobase_strip_setup); \
-  for p in $$list; do echo "$$p $$p"; done | \
-  sed "s| $$srcdirstrip/| |;"' / .*\//!s/ .*/ ./; s,\( .*\)/[^/]*$$,\1,' | \
-  $(AWK) 'BEGIN { files["."] = "" } { files[$$2] = files[$$2] " " $$1; \
-    if (++n[$$2] == $(am__install_max)) \
-      { print $$2, files[$$2]; n[$$2] = 0; files[$$2] = "" } } \
-    END { for (dir in files) print dir, files[dir] }'
-am__base_list = \
-  sed '$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;s/\n/ /g' | \
-  sed '$$!N;$$!N;$$!N;$$!N;s/\n/ /g'
-am__uninstall_files_from_dir = { \
-  test -z "$$files" \
-    || { test ! -d "$$dir" && test ! -f "$$dir" && test ! -r "$$dir"; } \
-    || { echo " ( cd '$$dir' && rm -f" $$files ")"; \
-         $(am__cd) "$$dir" && rm -f $$files; }; \
+  }
-man1dir = $(mandir)/man1
-am__installdirs = "$(DESTDIR)$(man1dir)"
-NROFF = nroff
-MANS = $(man1_MANS)
 RECURSIVE_CLEAN_TARGETS = mostlyclean-recursive clean-recursive \
   distclean-recursive maintainer-clean-recursive
 …
         $(top_srcdir)/automake/install-sh \
         $(top_srcdir)/automake/missing INSTALL README automake/compile \
         automake/config.guess automake/config.sub automake/install-sh \
         automake/missing
+        automake/config.guess automake/config.sub automake/depcomp \
+        automake/install-sh automake/missing automake/ylwrap
 DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)
 distdir = $(PACKAGE)-$(VERSION)
 …
 EXTRA_DIST = Docs                       # non-source files
 MAINTAINERCLEANFILES = lib/* bin/* src/examples/.deps/* src/tests/.deps/* src/tests/.out/*
-man1_MANS = doc/man/cfa.1
 all: config.h
         $(MAKE) $(AM_MAKEFLAGS) all-recursive
 …
 distclean-hdr:
         -rm -f config.h stamp-h1
-install-man1: $(man1_MANS)
-        @$(NORMAL_INSTALL)
-        @list1='$(man1_MANS)'; \
-        list2=''; \
-        test -n "$(man1dir)" \
-          && test -n "`echo $$list1$$list2`" \
-          || exit 0; \
-        echo " $(MKDIR_P) '$(DESTDIR)$(man1dir)'"; \
-        $(MKDIR_P) "$(DESTDIR)$(man1dir)" || exit 1; \
-        { for i in $$list1; do echo "$$i"; done;  \
-        if test -n "$$list2"; then \
-          for i in $$list2; do echo "$$i"; done \
-            | sed -n '/\.1[a-z]*$$/p'; \
-        fi; \
-        } | while read p; do \
-          if test -f $$p; then d=; else d="$(srcdir)/"; fi; \
-          echo "$$d$$p"; echo "$$p"; \
-        done | \
-        sed -e 'n;s,.*/,,;p;h;s,.*\.,,;s,^[^1][0-9a-z]*$$,1,;x' \
-              -e 's,\.[0-9a-z]*$$,,;$(transform);G;s,\n,.,' | \
-        sed 'N;N;s,\n, ,g' | { \
-        list=; while read file base inst; do \
-          if test "$$base" = "$$inst"; then list="$$list $$file"; else \
-            echo " $(INSTALL_DATA) '$$file' '$(DESTDIR)$(man1dir)/$$inst'"; \
-            $(INSTALL_DATA) "$$file" "$(DESTDIR)$(man1dir)/$$inst" || exit $$?; \
-          fi; \
-        done; \
-        for i in $$list; do echo "$$i"; done | $(am__base_list) | \
-        while read files; do \
-          test -z "$$files" || { \
-            echo " $(INSTALL_DATA) $$files '$(DESTDIR)$(man1dir)'"; \
-            $(INSTALL_DATA) $$files "$(DESTDIR)$(man1dir)" || exit $$?; }; \
-        done; }
-uninstall-man1:
-        @$(NORMAL_UNINSTALL)
-        @list='$(man1_MANS)'; test -n "$(man1dir)" || exit 0; \
-        files=`{ for i in $$list; do echo "$$i"; done; \
-        } | sed -e 's,.*/,,;h;s,.*\.,,;s,^[^1][0-9a-z]*$$,1,;x' \
-              -e 's,\.[0-9a-z]*$$,,;$(transform);G;s,\n,.,'`; \
-        dir='$(DESTDIR)$(man1dir)'; $(am__uninstall_files_from_dir)
 # This directory's subdirectories are mostly independent; you can cd
 …
 check-am: all-am
 check: check-recursive
 all-am: Makefile $(MANS) config.h
+all-am: Makefile config.h
 installdirs: installdirs-recursive
 installdirs-am:
-        for dir in "$(DESTDIR)$(man1dir)"; do \
-          test -z "$$dir" || $(MKDIR_P) "$$dir"; \
-        done
 install: install-recursive
 install-exec: install-exec-recursive
 …
 info-am:
 install-data-am: install-man
+install-data-am:
 install-dvi: install-dvi-recursive
 …
 install-info-am:
 install-man: install-man1
+install-man:
 install-pdf: install-pdf-recursive
 …
 ps-am:
+uninstall-am: uninstall-man
+uninstall-man: uninstall-man1
+uninstall-am:
 .MAKE: $(am__recursive_targets) all install-am install-strip
 …
         install-data install-data-am install-dvi install-dvi-am \
         install-exec install-exec-am install-html install-html-am \
         install-info install-info-am install-man install-man1 \
         install-pdf install-pdf-am install-ps install-ps-am \
         install-strip installcheck installcheck-am installdirs \
         installdirs-am maintainer-clean maintainer-clean-generic \
         mostlyclean mostlyclean-generic pdf pdf-am ps ps-am tags \
         tags-am uninstall uninstall-am uninstall-man uninstall-man1
+        install-info install-info-am install-man install-pdf \
+        install-pdf-am install-ps install-ps-am install-strip \
+        installcheck installcheck-am installdirs installdirs-am \
+        maintainer-clean maintainer-clean-generic mostlyclean \
+        mostlyclean-generic pdf pdf-am ps ps-am tags tags-am uninstall \
+        uninstall-am
 .PRECIOUS: Makefile

automake/compile

-              r0720e049
+              r3d4b23fa
 # Wrapper for compilers which do not understand '-c -o'.
+scriptversion=2012-10-14.11; # UTC
+# Copyright (C) 1999-2014 Free Software Foundation, Inc.
+scriptversion=2012-01-04.17; # UTC
+# Copyright (C) 1999, 2000, 2003, 2004, 2005, 2009, 2010, 2012 Free
+# Software Foundation, Inc.
 # Written by Tom Tromey <tromey@cygnus.com>.
+#
 …
       ;;
   esac
+}
-# func_cl_dashL linkdir
-# Make cl look for libraries in LINKDIR
-func_cl_dashL ()
+{
-  func_file_conv "$1"
-  if test -z "$lib_path"; then
-    lib_path=$file
-  else
-    lib_path="$lib_path;$file"
-  fi
-  linker_opts="$linker_opts -LIBPATH:$file"
+}
-# func_cl_dashl library
-# Do a library search-path lookup for cl
-func_cl_dashl ()
+{
-  lib=$1
-  found=no
-  save_IFS=$IFS
-  IFS=';'
-  for dir in $lib_path $LIB
-  do
-    IFS=$save_IFS
-    if $shared && test -f "$dir/$lib.dll.lib"; then
-      found=yes
-      lib=$dir/$lib.dll.lib
-      break
-    fi
-    if test -f "$dir/$lib.lib"; then
-      found=yes
-      lib=$dir/$lib.lib
-      break
-    fi
-    if test -f "$dir/lib$lib.a"; then
-      found=yes
-      lib=$dir/lib$lib.a
-      break
-    fi
-  done
-  IFS=$save_IFS
-  if test "$found" != yes; then
-    lib=$lib.lib
-  fi
+}
 …
           esac
           ;;
-        -I)
-          eat=1
-          func_file_conv "$2" mingw
-          set x "$@" -I"$file"
-          shift
-          ;;
         -I*)
           func_file_conv "${1#-I}" mingw
 …
           shift
           ;;
-        -l)
-          eat=1
-          func_cl_dashl "$2"
-          set x "$@" "$lib"
-          shift
-          ;;
         -l*)
+          func_cl_dashl "${1#-l}"
+          set x "$@" "$lib"
+          shift
+          ;;
+        -L)
+          eat=1
+          func_cl_dashL "$2"
+          lib=${1#-l}
+          found=no
+          save_IFS=$IFS
+          IFS=';'
+          for dir in $lib_path $LIB
+          do
+            IFS=$save_IFS
+            if $shared && test -f "$dir/$lib.dll.lib"; then
+              found=yes
+              set x "$@" "$dir/$lib.dll.lib"
+              break
+            fi
+            if test -f "$dir/$lib.lib"; then
+              found=yes
+              set x "$@" "$dir/$lib.lib"
+              break
+            fi
+          done
+          IFS=$save_IFS
+          test "$found" != yes && set x "$@" "$lib.lib"
+          shift
           ;;
         -L*)
+          func_cl_dashL "${1#-L}"
+          func_file_conv "${1#-L}"
+          if test -z "$lib_path"; then
+            lib_path=$file
+          else
+            lib_path="$lib_path;$file"
+          fi
+          linker_opts="$linker_opts -LIBPATH:$file"
           ;;
         -static)

automake/config.guess

Property mode changed from 100755 to 120000

-              r0720e049
+              r3d4b23fa
+#! /bin/sh
+# Attempt to guess a canonical system name.
+#   Copyright 1992-2015 Free Software Foundation, Inc.
+timestamp='2015-08-20'
+# This file is free software; you can redistribute it and/or modify it
+# under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, see <http://www.gnu.org/licenses/>.
+#
+# As a special exception to the GNU General Public License, if you
+# distribute this file as part of a program that contains a
+# configuration script generated by Autoconf, you may include it under
+# the same distribution terms that you use for the rest of that
+# program.  This Exception is an additional permission under section 7
+# of the GNU General Public License, version 3 ("GPLv3").
+#
+# Originally written by Per Bothner; maintained since 2000 by Ben Elliston.
+#
+# You can get the latest version of this script from:
+# http://git.savannah.gnu.org/gitweb/?p=config.git;a=blob_plain;f=config.guess;hb=HEAD
+#
+# Please send patches to <config-patches@gnu.org>.
+me=`echo "$0" | sed -e 's,.*/,,'`
+usage="\
+Usage: $0 [OPTION]
+Output the configuration name of the system \`$me' is run on.
+Operation modes:
+  -h, --help         print this help, then exit
+  -t, --time-stamp   print date of last modification, then exit
+  -v, --version      print version number, then exit
+Report bugs and patches to <config-patches@gnu.org>."
+version="\
+GNU config.guess ($timestamp)
+Originally written by Per Bothner.
+Copyright 1992-2015 Free Software Foundation, Inc.
+This is free software; see the source for copying conditions.  There is NO
+warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE."
+help="
+Try \`$me --help' for more information."
+# Parse command line
+while test $# -gt 0 ; do
+  case $1 in
+    --time-stamp | --time* | -t )
+       echo "$timestamp" ; exit ;;
+    --version | -v )
+       echo "$version" ; exit ;;
+    --help | --h* | -h )
+       echo "$usage"; exit ;;
+    -- )     # Stop option processing
+       shift; break ;;
+    - ) # Use stdin as input.
+       break ;;
+    -* )
+       echo "$me: invalid option $1$help" >&2
+       exit 1 ;;
+    * )
+       break ;;
+  esac
+done
+if test $# != 0; then
+  echo "$me: too many arguments$help" >&2
+  exit 1
+fi
+trap 'exit 1' 1 2 15
+# CC_FOR_BUILD -- compiler used by this script. Note that the use of a
+# compiler to aid in system detection is discouraged as it requires
+# temporary files to be created and, as you can see below, it is a
+# headache to deal with in a portable fashion.
+# Historically, `CC_FOR_BUILD' used to be named `HOST_CC'. We still
+# use `HOST_CC' if defined, but it is deprecated.
+# Portable tmp directory creation inspired by the Autoconf team.
+set_cc_for_build='
+trap "exitcode=\$?; (rm -f \$tmpfiles 2>/dev/null; rmdir \$tmp 2>/dev/null) && exit \$exitcode" 0 ;
+trap "rm -f \$tmpfiles 2>/dev/null; rmdir \$tmp 2>/dev/null; exit 1" 1 2 13 15 ;
+: ${TMPDIR=/tmp} ;
+ { tmp=`(umask 077 && mktemp -d "$TMPDIR/cgXXXXXX") 2>/dev/null` && test -n "$tmp" && test -d "$tmp" ; } ||
+ { test -n "$RANDOM" && tmp=$TMPDIR/cg$$-$RANDOM && (umask 077 && mkdir $tmp) ; } ||
+ { tmp=$TMPDIR/cg-$$ && (umask 077 && mkdir $tmp) && echo "Warning: creating insecure temp directory" >&2 ; } ||
+ { echo "$me: cannot create a temporary directory in $TMPDIR" >&2 ; exit 1 ; } ;
+dummy=$tmp/dummy ;
+tmpfiles="$dummy.c $dummy.o $dummy.rel $dummy" ;
+case $CC_FOR_BUILD,$HOST_CC,$CC in
+ ,,)    echo "int x;" > $dummy.c ;
+        for c in cc gcc c89 c99 ; do
+          if ($c -c -o $dummy.o $dummy.c) >/dev/null 2>&1 ; then
+             CC_FOR_BUILD="$c"; break ;
+          fi ;
+        done ;
+        if test x"$CC_FOR_BUILD" = x ; then
+          CC_FOR_BUILD=no_compiler_found ;
+        fi
+        ;;
+ ,,*)   CC_FOR_BUILD=$CC ;;
+ ,*,*)  CC_FOR_BUILD=$HOST_CC ;;
+esac ; set_cc_for_build= ;'
+# This is needed to find uname on a Pyramid OSx when run in the BSD universe.
+# (ghazi@noc.rutgers.edu 1994-08-24)
+if (test -f /.attbin/uname) >/dev/null 2>&1 ; then
+        PATH=$PATH:/.attbin ; export PATH
+fi
+UNAME_MACHINE=`(uname -m) 2>/dev/null` || UNAME_MACHINE=unknown
+UNAME_RELEASE=`(uname -r) 2>/dev/null` || UNAME_RELEASE=unknown
+UNAME_SYSTEM=`(uname -s) 2>/dev/null`  || UNAME_SYSTEM=unknown
+UNAME_VERSION=`(uname -v) 2>/dev/null` || UNAME_VERSION=unknown
+case "${UNAME_SYSTEM}" in
+Linux|GNU|GNU/*)
+        # If the system lacks a compiler, then just pick glibc.
+        # We could probably try harder.
+        LIBC=gnu
+        eval $set_cc_for_build
+        cat <<-EOF > $dummy.c
+        #include <features.h>
+        #if defined(__UCLIBC__)
+        LIBC=uclibc
+        #elif defined(__dietlibc__)
+        LIBC=dietlibc
+        #else
+        LIBC=gnu
+        #endif
+        EOF
+        eval `$CC_FOR_BUILD -E $dummy.c 2>/dev/null | grep '^LIBC' | sed 's, ,,g'`
+        ;;
+esac
+# Note: order is significant - the case branches are not exclusive.
+case "${UNAME_MACHINE}:${UNAME_SYSTEM}:${UNAME_RELEASE}:${UNAME_VERSION}" in
+    *:NetBSD:*:*)
+        # NetBSD (nbsd) targets should (where applicable) match one or
+        # more of the tuples: *-*-netbsdelf*, *-*-netbsdaout*,
+        # *-*-netbsdecoff* and *-*-netbsd*.  For targets that recently
+        # switched to ELF, *-*-netbsd* would select the old
+        # object file format.  This provides both forward
+        # compatibility and a consistent mechanism for selecting the
+        # object file format.
+        #
+        # Note: NetBSD doesn't particularly care about the vendor
+        # portion of the name.  We always set it to "unknown".
+        sysctl="sysctl -n hw.machine_arch"
+        UNAME_MACHINE_ARCH=`(uname -p 2>/dev/null || \
+            /sbin/$sysctl 2>/dev/null || \
+            /usr/sbin/$sysctl 2>/dev/null || \
+            echo unknown)`
+        case "${UNAME_MACHINE_ARCH}" in
+            armeb) machine=armeb-unknown ;;
+            arm*) machine=arm-unknown ;;
+            sh3el) machine=shl-unknown ;;
+            sh3eb) machine=sh-unknown ;;
+            sh5el) machine=sh5le-unknown ;;
+            earmv*)
+                arch=`echo ${UNAME_MACHINE_ARCH} | sed -e 's,^e\(armv[0-9]\).*$,\1,'`
+                endian=`echo ${UNAME_MACHINE_ARCH} | sed -ne 's,^.*\(eb\)$,\1,p'`
+                machine=${arch}${endian}-unknown
+                ;;
+            *) machine=${UNAME_MACHINE_ARCH}-unknown ;;
+        esac
+        # The Operating System including object format, if it has switched
+        # to ELF recently, or will in the future.
+        case "${UNAME_MACHINE_ARCH}" in
+            arm*|earm*|i386|m68k|ns32k|sh3*|sparc|vax)
+                eval $set_cc_for_build
+                if echo __ELF__ | $CC_FOR_BUILD -E - 2>/dev/null \
+                        | grep -q __ELF__
+                then
+                    # Once all utilities can be ECOFF (netbsdecoff) or a.out (netbsdaout).
+                    # Return netbsd for either.  FIX?
+                    os=netbsd
+                else
+                    os=netbsdelf
+                fi
+                ;;
+            *)
+                os=netbsd
+                ;;
+        esac
+        # Determine ABI tags.
+        case "${UNAME_MACHINE_ARCH}" in
+            earm*)
+                expr='s/^earmv[0-9]/-eabi/;s/eb$//'
+                abi=`echo ${UNAME_MACHINE_ARCH} | sed -e "$expr"`
+                ;;
+        esac
+        # The OS release
+        # Debian GNU/NetBSD machines have a different userland, and
+        # thus, need a distinct triplet. However, they do not need
+        # kernel version information, so it can be replaced with a
+        # suitable tag, in the style of linux-gnu.
+        case "${UNAME_VERSION}" in
+            Debian*)
+                release='-gnu'
+                ;;
+            *)
+                release=`echo ${UNAME_RELEASE} | sed -e 's/[-_].*//' | cut -d. -f1,2`
+                ;;
+        esac
+        # Since CPU_TYPE-MANUFACTURER-KERNEL-OPERATING_SYSTEM:
+        # contains redundant information, the shorter form:
+        # CPU_TYPE-MANUFACTURER-OPERATING_SYSTEM is used.
+        echo "${machine}-${os}${release}${abi}"
+        exit ;;
+    *:Bitrig:*:*)
+        UNAME_MACHINE_ARCH=`arch | sed 's/Bitrig.//'`
+        echo ${UNAME_MACHINE_ARCH}-unknown-bitrig${UNAME_RELEASE}
+        exit ;;
+    *:OpenBSD:*:*)
+        UNAME_MACHINE_ARCH=`arch | sed 's/OpenBSD.//'`
+        echo ${UNAME_MACHINE_ARCH}-unknown-openbsd${UNAME_RELEASE}
+        exit ;;
+    *:ekkoBSD:*:*)
+        echo ${UNAME_MACHINE}-unknown-ekkobsd${UNAME_RELEASE}
+        exit ;;
+    *:SolidBSD:*:*)
+        echo ${UNAME_MACHINE}-unknown-solidbsd${UNAME_RELEASE}
+        exit ;;
+    macppc:MirBSD:*:*)
+        echo powerpc-unknown-mirbsd${UNAME_RELEASE}
+        exit ;;
+    *:MirBSD:*:*)
+        echo ${UNAME_MACHINE}-unknown-mirbsd${UNAME_RELEASE}
+        exit ;;
+    *:Sortix:*:*)
+        echo ${UNAME_MACHINE}-unknown-sortix
+        exit ;;
+    alpha:OSF1:*:*)
+        case $UNAME_RELEASE in
+        *4.0)
+                UNAME_RELEASE=`/usr/sbin/sizer -v | awk '{print $3}'`
+                ;;
+        *5.*)
+                UNAME_RELEASE=`/usr/sbin/sizer -v | awk '{print $4}'`
+                ;;
+        esac
+        # According to Compaq, /usr/sbin/psrinfo has been available on
+        # OSF/1 and Tru64 systems produced since 1995.  I hope that
+        # covers most systems running today.  This code pipes the CPU
+        # types through head -n 1, so we only detect the type of CPU 0.
+        ALPHA_CPU_TYPE=`/usr/sbin/psrinfo -v | sed -n -e 's/^  The alpha \(.*\) processor.*$/\1/p' | head -n 1`
+        case "$ALPHA_CPU_TYPE" in
+            "EV4 (21064)")
+                UNAME_MACHINE="alpha" ;;
+            "EV4.5 (21064)")
+                UNAME_MACHINE="alpha" ;;
+            "LCA4 (21066/21068)")
+                UNAME_MACHINE="alpha" ;;
+            "EV5 (21164)")
+                UNAME_MACHINE="alphaev5" ;;
+            "EV5.6 (21164A)")
+                UNAME_MACHINE="alphaev56" ;;
+            "EV5.6 (21164PC)")
+                UNAME_MACHINE="alphapca56" ;;
+            "EV5.7 (21164PC)")
+                UNAME_MACHINE="alphapca57" ;;
+            "EV6 (21264)")
+                UNAME_MACHINE="alphaev6" ;;
+            "EV6.7 (21264A)")
+                UNAME_MACHINE="alphaev67" ;;
+            "EV6.8CB (21264C)")
+                UNAME_MACHINE="alphaev68" ;;
+            "EV6.8AL (21264B)")
+                UNAME_MACHINE="alphaev68" ;;
+            "EV6.8CX (21264D)")
+                UNAME_MACHINE="alphaev68" ;;
+            "EV6.9A (21264/EV69A)")
+                UNAME_MACHINE="alphaev69" ;;
+            "EV7 (21364)")
+                UNAME_MACHINE="alphaev7" ;;
+            "EV7.9 (21364A)")
+                UNAME_MACHINE="alphaev79" ;;
+        esac
+        # A Pn.n version is a patched version.
+        # A Vn.n version is a released version.
+        # A Tn.n version is a released field test version.
+        # A Xn.n version is an unreleased experimental baselevel.
+        # 1.2 uses "1.2" for uname -r.
+        echo ${UNAME_MACHINE}-dec-osf`echo ${UNAME_RELEASE} | sed -e 's/^[PVTX]//' | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
+        # Reset EXIT trap before exiting to avoid spurious non-zero exit code.
+        exitcode=$?
+        trap '' 0
+        exit $exitcode ;;
+    Alpha\ *:Windows_NT*:*)
+        # How do we know it's Interix rather than the generic POSIX subsystem?
+        # Should we change UNAME_MACHINE based on the output of uname instead
+        # of the specific Alpha model?
+        echo alpha-pc-interix
+        exit ;;
+:Windows_NT:50:3)
+        echo alpha-dec-winnt3.5
+        exit ;;
+    Amiga*:UNIX_System_V:4.0:*)
+        echo m68k-unknown-sysv4
+        exit ;;
+    *:[Aa]miga[Oo][Ss]:*:*)
+        echo ${UNAME_MACHINE}-unknown-amigaos
+        exit ;;
+    *:[Mm]orph[Oo][Ss]:*:*)
+        echo ${UNAME_MACHINE}-unknown-morphos
+        exit ;;
+    *:OS/390:*:*)
+        echo i370-ibm-openedition
+        exit ;;
+    *:z/VM:*:*)
+        echo s390-ibm-zvmoe
+        exit ;;
+    *:OS400:*:*)
+        echo powerpc-ibm-os400
+        exit ;;
+    arm:RISC*:1.[012]*:*|arm:riscix:1.[012]*:*)
+        echo arm-acorn-riscix${UNAME_RELEASE}
+        exit ;;
+    arm*:riscos:*:*|arm*:RISCOS:*:*)
+        echo arm-unknown-riscos
+        exit ;;
+    SR2?01:HI-UX/MPP:*:* | SR8000:HI-UX/MPP:*:*)
+        echo hppa1.1-hitachi-hiuxmpp
+        exit ;;
+    Pyramid*:OSx*:*:* | MIS*:OSx*:*:* | MIS*:SMP_DC-OSx*:*:*)
+        # akee@wpdis03.wpafb.af.mil (Earle F. Ake) contributed MIS and NILE.
+        if test "`(/bin/universe) 2>/dev/null`" = att ; then
+                echo pyramid-pyramid-sysv3
+        else
+                echo pyramid-pyramid-bsd
+        fi
+        exit ;;
+    NILE*:*:*:dcosx)
+        echo pyramid-pyramid-svr4
+        exit ;;
+    DRS?6000:unix:4.0:6*)
+        echo sparc-icl-nx6
+        exit ;;
+    DRS?6000:UNIX_SV:4.2*:7* | DRS?6000:isis:4.2*:7*)
+        case `/usr/bin/uname -p` in
+            sparc) echo sparc-icl-nx7; exit ;;
+        esac ;;
+    s390x:SunOS:*:*)
+        echo ${UNAME_MACHINE}-ibm-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'`
+        exit ;;
+    sun4H:SunOS:5.*:*)
+        echo sparc-hal-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'`
+        exit ;;
+    sun4*:SunOS:5.*:* | tadpole*:SunOS:5.*:*)
+        echo sparc-sun-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'`
+        exit ;;
+    i86pc:AuroraUX:5.*:* | i86xen:AuroraUX:5.*:*)
+        echo i386-pc-auroraux${UNAME_RELEASE}
+        exit ;;
+    i86pc:SunOS:5.*:* | i86xen:SunOS:5.*:*)
+        eval $set_cc_for_build
+        SUN_ARCH="i386"
+        # If there is a compiler, see if it is configured for 64-bit objects.
+        # Note that the Sun cc does not turn __LP64__ into 1 like gcc does.
+        # This test works for both compilers.
+        if [ "$CC_FOR_BUILD" != 'no_compiler_found' ]; then
+            if (echo '#ifdef __amd64'; echo IS_64BIT_ARCH; echo '#endif') | \
+                (CCOPTS= $CC_FOR_BUILD -E - 2>/dev/null) | \
+                grep IS_64BIT_ARCH >/dev/null
+            then
+                SUN_ARCH="x86_64"
+            fi
+        fi
+        echo ${SUN_ARCH}-pc-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'`
+        exit ;;
+    sun4*:SunOS:6*:*)
+        # According to config.sub, this is the proper way to canonicalize
+        # SunOS6.  Hard to guess exactly what SunOS6 will be like, but
+        # it's likely to be more like Solaris than SunOS4.
+        echo sparc-sun-solaris3`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'`
+        exit ;;
+    sun4*:SunOS:*:*)
+        case "`/usr/bin/arch -k`" in
+            Series*|S4*)
+                UNAME_RELEASE=`uname -v`
+                ;;
+        esac
+        # Japanese Language versions have a version number like `4.1.3-JL'.
+        echo sparc-sun-sunos`echo ${UNAME_RELEASE}|sed -e 's/-/_/'`
+        exit ;;
+    sun3*:SunOS:*:*)
+        echo m68k-sun-sunos${UNAME_RELEASE}
+        exit ;;
+    sun*:*:4.2BSD:*)
+        UNAME_RELEASE=`(sed 1q /etc/motd | awk '{print substr($5,1,3)}') 2>/dev/null`
+        test "x${UNAME_RELEASE}" = "x" && UNAME_RELEASE=3
+        case "`/bin/arch`" in
+            sun3)
+                echo m68k-sun-sunos${UNAME_RELEASE}
+                ;;
+            sun4)
+                echo sparc-sun-sunos${UNAME_RELEASE}
+                ;;
+        esac
+        exit ;;
+    aushp:SunOS:*:*)
+        echo sparc-auspex-sunos${UNAME_RELEASE}
+        exit ;;
+    # The situation for MiNT is a little confusing.  The machine name
+    # can be virtually everything (everything which is not
+    # "atarist" or "atariste" at least should have a processor
+    # > m68000).  The system name ranges from "MiNT" over "FreeMiNT"
+    # to the lowercase version "mint" (or "freemint").  Finally
+    # the system name "TOS" denotes a system which is actually not
+    # MiNT.  But MiNT is downward compatible to TOS, so this should
+    # be no problem.
+    atarist[e]:*MiNT:*:* | atarist[e]:*mint:*:* | atarist[e]:*TOS:*:*)
+        echo m68k-atari-mint${UNAME_RELEASE}
+        exit ;;
+    atari*:*MiNT:*:* | atari*:*mint:*:* | atarist[e]:*TOS:*:*)
+        echo m68k-atari-mint${UNAME_RELEASE}
+        exit ;;
+    *falcon*:*MiNT:*:* | *falcon*:*mint:*:* | *falcon*:*TOS:*:*)
+        echo m68k-atari-mint${UNAME_RELEASE}
+        exit ;;
+    milan*:*MiNT:*:* | milan*:*mint:*:* | *milan*:*TOS:*:*)
+        echo m68k-milan-mint${UNAME_RELEASE}
+        exit ;;
+    hades*:*MiNT:*:* | hades*:*mint:*:* | *hades*:*TOS:*:*)
+        echo m68k-hades-mint${UNAME_RELEASE}
+        exit ;;
+    *:*MiNT:*:* | *:*mint:*:* | *:*TOS:*:*)
+        echo m68k-unknown-mint${UNAME_RELEASE}
+        exit ;;
+    m68k:machten:*:*)
+        echo m68k-apple-machten${UNAME_RELEASE}
+        exit ;;
+    powerpc:machten:*:*)
+        echo powerpc-apple-machten${UNAME_RELEASE}
+        exit ;;
+    RISC*:Mach:*:*)
+        echo mips-dec-mach_bsd4.3
+        exit ;;
+    RISC*:ULTRIX:*:*)
+        echo mips-dec-ultrix${UNAME_RELEASE}
+        exit ;;
+    VAX*:ULTRIX*:*:*)
+        echo vax-dec-ultrix${UNAME_RELEASE}
+        exit ;;
+:CLIX:*:* | 2430:CLIX:*:*)
+        echo clipper-intergraph-clix${UNAME_RELEASE}
+        exit ;;
+    mips:*:*:UMIPS | mips:*:*:RISCos)
+        eval $set_cc_for_build
+        sed 's/^        //' << EOF >$dummy.c
+#ifdef __cplusplus
+#include <stdio.h>  /* for printf() prototype */
+        int main (int argc, char *argv[]) {
+#else
+        int main (argc, argv) int argc; char *argv[]; {
+#endif
+        #if defined (host_mips) && defined (MIPSEB)
+        #if defined (SYSTYPE_SYSV)
+          printf ("mips-mips-riscos%ssysv\n", argv[1]); exit (0);
+        #endif
+        #if defined (SYSTYPE_SVR4)
+          printf ("mips-mips-riscos%ssvr4\n", argv[1]); exit (0);
+        #endif
+        #if defined (SYSTYPE_BSD43) || defined(SYSTYPE_BSD)
+          printf ("mips-mips-riscos%sbsd\n", argv[1]); exit (0);
+        #endif
+        #endif
+          exit (-1);
+        }
+EOF
+        $CC_FOR_BUILD -o $dummy $dummy.c &&
+          dummyarg=`echo "${UNAME_RELEASE}" | sed -n 's/\([0-9]*\).*/\1/p'` &&
+          SYSTEM_NAME=`$dummy $dummyarg` &&
+            { echo "$SYSTEM_NAME"; exit; }
+        echo mips-mips-riscos${UNAME_RELEASE}
+        exit ;;
+    Motorola:PowerMAX_OS:*:*)
+        echo powerpc-motorola-powermax
+        exit ;;
+    Motorola:*:4.3:PL8-*)
+        echo powerpc-harris-powermax
+        exit ;;
+    Night_Hawk:*:*:PowerMAX_OS | Synergy:PowerMAX_OS:*:*)
+        echo powerpc-harris-powermax
+        exit ;;
+    Night_Hawk:Power_UNIX:*:*)
+        echo powerpc-harris-powerunix
+        exit ;;
+    m88k:CX/UX:7*:*)
+        echo m88k-harris-cxux7
+        exit ;;
+    m88k:*:4*:R4*)
+        echo m88k-motorola-sysv4
+        exit ;;
+    m88k:*:3*:R3*)
+        echo m88k-motorola-sysv3
+        exit ;;
+    AViiON:dgux:*:*)
+        # DG/UX returns AViiON for all architectures
+        UNAME_PROCESSOR=`/usr/bin/uname -p`
+        if [ $UNAME_PROCESSOR = mc88100 ] || [ $UNAME_PROCESSOR = mc88110 ]
+        then
+            if [ ${TARGET_BINARY_INTERFACE}x = m88kdguxelfx ] || \
+               [ ${TARGET_BINARY_INTERFACE}x = x ]
+            then
+                echo m88k-dg-dgux${UNAME_RELEASE}
+            else
+                echo m88k-dg-dguxbcs${UNAME_RELEASE}
+            fi
+        else
+            echo i586-dg-dgux${UNAME_RELEASE}
+        fi
+        exit ;;
+    M88*:DolphinOS:*:*) # DolphinOS (SVR3)
+        echo m88k-dolphin-sysv3
+        exit ;;
+    M88*:*:R3*:*)
+        # Delta 88k system running SVR3
+        echo m88k-motorola-sysv3
+        exit ;;
+    XD88*:*:*:*) # Tektronix XD88 system running UTekV (SVR3)
+        echo m88k-tektronix-sysv3
+        exit ;;
+    Tek43[0-9][0-9]:UTek:*:*) # Tektronix 4300 system running UTek (BSD)
+        echo m68k-tektronix-bsd
+        exit ;;
+    *:IRIX*:*:*)
+        echo mips-sgi-irix`echo ${UNAME_RELEASE}|sed -e 's/-/_/g'`
+        exit ;;
+    ????????:AIX?:[12].1:2)   # AIX 2.2.1 or AIX 2.1.1 is RT/PC AIX.
+        echo romp-ibm-aix     # uname -m gives an 8 hex-code CPU id
+        exit ;;               # Note that: echo "'`uname -s`'" gives 'AIX '
+    i*86:AIX:*:*)
+        echo i386-ibm-aix
+        exit ;;
+    ia64:AIX:*:*)
+        if [ -x /usr/bin/oslevel ] ; then
+                IBM_REV=`/usr/bin/oslevel`
+        else
+                IBM_REV=${UNAME_VERSION}.${UNAME_RELEASE}
+        fi
+        echo ${UNAME_MACHINE}-ibm-aix${IBM_REV}
+        exit ;;
+    *:AIX:2:3)
+        if grep bos325 /usr/include/stdio.h >/dev/null 2>&1; then
+                eval $set_cc_for_build
+                sed 's/^                //' << EOF >$dummy.c
+                #include <sys/systemcfg.h>
+                main()
+                        {
+                        if (!__power_pc())
+                                exit(1);
+                        puts("powerpc-ibm-aix3.2.5");
+                        exit(0);
+                        }
+EOF
+                if $CC_FOR_BUILD -o $dummy $dummy.c && SYSTEM_NAME=`$dummy`
+                then
+                        echo "$SYSTEM_NAME"
+                else
+                        echo rs6000-ibm-aix3.2.5
+                fi
+        elif grep bos324 /usr/include/stdio.h >/dev/null 2>&1; then
+                echo rs6000-ibm-aix3.2.4
+        else
+                echo rs6000-ibm-aix3.2
+        fi
+        exit ;;
+    *:AIX:*:[4567])
+        IBM_CPU_ID=`/usr/sbin/lsdev -C -c processor -S available | sed 1q | awk '{ print $1 }'`
+        if /usr/sbin/lsattr -El ${IBM_CPU_ID} | grep ' POWER' >/dev/null 2>&1; then
+                IBM_ARCH=rs6000
+        else
+                IBM_ARCH=powerpc
+        fi
+        if [ -x /usr/bin/lslpp ] ; then
+                IBM_REV=`/usr/bin/lslpp -Lqc bos.rte.libc |
+                           awk -F: '{ print $3 }' | sed s/[0-9]*$/0/`
+        else
+                IBM_REV=${UNAME_VERSION}.${UNAME_RELEASE}
+        fi
+        echo ${IBM_ARCH}-ibm-aix${IBM_REV}
+        exit ;;
+    *:AIX:*:*)
+        echo rs6000-ibm-aix
+        exit ;;
+    ibmrt:4.4BSD:*|romp-ibm:BSD:*)
+        echo romp-ibm-bsd4.4
+        exit ;;
+    ibmrt:*BSD:*|romp-ibm:BSD:*)            # covers RT/PC BSD and
+        echo romp-ibm-bsd${UNAME_RELEASE}   # 4.3 with uname added to
+        exit ;;                             # report: romp-ibm BSD 4.3
+    *:BOSX:*:*)
+        echo rs6000-bull-bosx
+        exit ;;
+    DPX/2?00:B.O.S.:*:*)
+        echo m68k-bull-sysv3
+        exit ;;
+/[34]??:4.3bsd:1.*:*)
+        echo m68k-hp-bsd
+        exit ;;
+    hp300:4.4BSD:*:* | 9000/[34]??:4.3bsd:2.*:*)
+        echo m68k-hp-bsd4.4
+        exit ;;
+/[34678]??:HP-UX:*:*)
+        HPUX_REV=`echo ${UNAME_RELEASE}|sed -e 's/[^.]*.[0B]*//'`
+        case "${UNAME_MACHINE}" in
+/31? )            HP_ARCH=m68000 ;;
+/[34]?? )         HP_ARCH=m68k ;;
+/[678][0-9][0-9])
+                if [ -x /usr/bin/getconf ]; then
+                    sc_cpu_version=`/usr/bin/getconf SC_CPU_VERSION 2>/dev/null`
+                    sc_kernel_bits=`/usr/bin/getconf SC_KERNEL_BITS 2>/dev/null`
+                    case "${sc_cpu_version}" in
+) HP_ARCH="hppa1.0" ;; # CPU_PA_RISC1_0
+) HP_ARCH="hppa1.1" ;; # CPU_PA_RISC1_1
+)                      # CPU_PA_RISC2_0
+                        case "${sc_kernel_bits}" in
+) HP_ARCH="hppa2.0n" ;;
+) HP_ARCH="hppa2.0w" ;;
+                          '') HP_ARCH="hppa2.0" ;;   # HP-UX 10.20
+                        esac ;;
+                    esac
+                fi
+                if [ "${HP_ARCH}" = "" ]; then
+                    eval $set_cc_for_build
+                    sed 's/^            //' << EOF >$dummy.c
+                #define _HPUX_SOURCE
+                #include <stdlib.h>
+                #include <unistd.h>
+                int main ()
+                {
+                #if defined(_SC_KERNEL_BITS)
+                    long bits = sysconf(_SC_KERNEL_BITS);
+                #endif
+                    long cpu  = sysconf (_SC_CPU_VERSION);
+                    switch (cpu)
+                        {
+                        case CPU_PA_RISC1_0: puts ("hppa1.0"); break;
+                        case CPU_PA_RISC1_1: puts ("hppa1.1"); break;
+                        case CPU_PA_RISC2_0:
+                #if defined(_SC_KERNEL_BITS)
+                            switch (bits)
+                                {
+                                case 64: puts ("hppa2.0w"); break;
+                                case 32: puts ("hppa2.0n"); break;
+                                default: puts ("hppa2.0"); break;
+                                } break;
+                #else  /* !defined(_SC_KERNEL_BITS) */
+                            puts ("hppa2.0"); break;
+                #endif
+                        default: puts ("hppa1.0"); break;
+                        }
+                    exit (0);
+                }
+EOF
+                    (CCOPTS= $CC_FOR_BUILD -o $dummy $dummy.c 2>/dev/null) && HP_ARCH=`$dummy`
+                    test -z "$HP_ARCH" && HP_ARCH=hppa
+                fi ;;
+        esac
+        if [ ${HP_ARCH} = "hppa2.0w" ]
+        then
+            eval $set_cc_for_build
+            # hppa2.0w-hp-hpux* has a 64-bit kernel and a compiler generating
+            # 32-bit code.  hppa64-hp-hpux* has the same kernel and a compiler
+            # generating 64-bit code.  GNU and HP use different nomenclature:
+            #
+            # $ CC_FOR_BUILD=cc ./config.guess
+            # => hppa2.0w-hp-hpux11.23
+            # $ CC_FOR_BUILD="cc +DA2.0w" ./config.guess
+            # => hppa64-hp-hpux11.23
+            if echo __LP64__ | (CCOPTS= $CC_FOR_BUILD -E - 2>/dev/null) |
+                grep -q __LP64__
+            then
+                HP_ARCH="hppa2.0w"
+            else
+                HP_ARCH="hppa64"
+            fi
+        fi
+        echo ${HP_ARCH}-hp-hpux${HPUX_REV}
+        exit ;;
+    ia64:HP-UX:*:*)
+        HPUX_REV=`echo ${UNAME_RELEASE}|sed -e 's/[^.]*.[0B]*//'`
+        echo ia64-hp-hpux${HPUX_REV}
+        exit ;;
+*:HI-UX:*:*)
+        eval $set_cc_for_build
+        sed 's/^        //' << EOF >$dummy.c
+        #include <unistd.h>
+        int
+        main ()
+        {
+          long cpu = sysconf (_SC_CPU_VERSION);
+          /* The order matters, because CPU_IS_HP_MC68K erroneously returns
+             true for CPU_PA_RISC1_0.  CPU_IS_PA_RISC returns correct
+             results, however.  */
+          if (CPU_IS_PA_RISC (cpu))
+            {
+              switch (cpu)
+                {
+                  case CPU_PA_RISC1_0: puts ("hppa1.0-hitachi-hiuxwe2"); break;
+                  case CPU_PA_RISC1_1: puts ("hppa1.1-hitachi-hiuxwe2"); break;
+                  case CPU_PA_RISC2_0: puts ("hppa2.0-hitachi-hiuxwe2"); break;
+                  default: puts ("hppa-hitachi-hiuxwe2"); break;
+                }
+            }
+          else if (CPU_IS_HP_MC68K (cpu))
+            puts ("m68k-hitachi-hiuxwe2");
+          else puts ("unknown-hitachi-hiuxwe2");
+          exit (0);
+        }
+EOF
+        $CC_FOR_BUILD -o $dummy $dummy.c && SYSTEM_NAME=`$dummy` &&
+                { echo "$SYSTEM_NAME"; exit; }
+        echo unknown-hitachi-hiuxwe2
+        exit ;;
+/7??:4.3bsd:*:* | 9000/8?[79]:4.3bsd:*:* )
+        echo hppa1.1-hp-bsd
+        exit ;;
+/8??:4.3bsd:*:*)
+        echo hppa1.0-hp-bsd
+        exit ;;
+    *9??*:MPE/iX:*:* | *3000*:MPE/iX:*:*)
+        echo hppa1.0-hp-mpeix
+        exit ;;
+    hp7??:OSF1:*:* | hp8?[79]:OSF1:*:* )
+        echo hppa1.1-hp-osf
+        exit ;;
+    hp8??:OSF1:*:*)
+        echo hppa1.0-hp-osf
+        exit ;;
+    i*86:OSF1:*:*)
+        if [ -x /usr/sbin/sysversion ] ; then
+            echo ${UNAME_MACHINE}-unknown-osf1mk
+        else
+            echo ${UNAME_MACHINE}-unknown-osf1
+        fi
+        exit ;;
+    parisc*:Lites*:*:*)
+        echo hppa1.1-hp-lites
+        exit ;;
+    C1*:ConvexOS:*:* | convex:ConvexOS:C1*:*)
+        echo c1-convex-bsd
+        exit ;;
+    C2*:ConvexOS:*:* | convex:ConvexOS:C2*:*)
+        if getsysinfo -f scalar_acc
+        then echo c32-convex-bsd
+        else echo c2-convex-bsd
+        fi
+        exit ;;
+    C34*:ConvexOS:*:* | convex:ConvexOS:C34*:*)
+        echo c34-convex-bsd
+        exit ;;
+    C38*:ConvexOS:*:* | convex:ConvexOS:C38*:*)
+        echo c38-convex-bsd
+        exit ;;
+    C4*:ConvexOS:*:* | convex:ConvexOS:C4*:*)
+        echo c4-convex-bsd
+        exit ;;
+    CRAY*Y-MP:*:*:*)
+        echo ymp-cray-unicos${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/'
+        exit ;;
+    CRAY*[A-Z]90:*:*:*)
+        echo ${UNAME_MACHINE}-cray-unicos${UNAME_RELEASE} \
+        | sed -e 's/CRAY.*\([A-Z]90\)/\1/' \
+              -e y/ABCDEFGHIJKLMNOPQRSTUVWXYZ/abcdefghijklmnopqrstuvwxyz/ \
+              -e 's/\.[^.]*$/.X/'
+        exit ;;
+    CRAY*TS:*:*:*)
+        echo t90-cray-unicos${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/'
+        exit ;;
+    CRAY*T3E:*:*:*)
+        echo alphaev5-cray-unicosmk${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/'
+        exit ;;
+    CRAY*SV1:*:*:*)
+        echo sv1-cray-unicos${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/'
+        exit ;;
+    *:UNICOS/mp:*:*)
+        echo craynv-cray-unicosmp${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/'
+        exit ;;
+    F30[01]:UNIX_System_V:*:* | F700:UNIX_System_V:*:*)
+        FUJITSU_PROC=`uname -m | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
+        FUJITSU_SYS=`uname -p | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz' | sed -e 's/\///'`
+        FUJITSU_REL=`echo ${UNAME_RELEASE} | sed -e 's/ /_/'`
+        echo "${FUJITSU_PROC}-fujitsu-${FUJITSU_SYS}${FUJITSU_REL}"
+        exit ;;
+:UNIX_System_V:4.*:*)
+        FUJITSU_SYS=`uname -p | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz' | sed -e 's/\///'`
+        FUJITSU_REL=`echo ${UNAME_RELEASE} | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz' | sed -e 's/ /_/'`
+        echo "sparc-fujitsu-${FUJITSU_SYS}${FUJITSU_REL}"
+        exit ;;
+    i*86:BSD/386:*:* | i*86:BSD/OS:*:* | *:Ascend\ Embedded/OS:*:*)
+        echo ${UNAME_MACHINE}-pc-bsdi${UNAME_RELEASE}
+        exit ;;
+    sparc*:BSD/OS:*:*)
+        echo sparc-unknown-bsdi${UNAME_RELEASE}
+        exit ;;
+    *:BSD/OS:*:*)
+        echo ${UNAME_MACHINE}-unknown-bsdi${UNAME_RELEASE}
+        exit ;;
+    *:FreeBSD:*:*)
+        UNAME_PROCESSOR=`/usr/bin/uname -p`
+        case ${UNAME_PROCESSOR} in
+            amd64)
+                echo x86_64-unknown-freebsd`echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'` ;;
+            *)
+                echo ${UNAME_PROCESSOR}-unknown-freebsd`echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'` ;;
+        esac
+        exit ;;
+    i*:CYGWIN*:*)
+        echo ${UNAME_MACHINE}-pc-cygwin
+        exit ;;
+    *:MINGW64*:*)
+        echo ${UNAME_MACHINE}-pc-mingw64
+        exit ;;
+    *:MINGW*:*)
+        echo ${UNAME_MACHINE}-pc-mingw32
+        exit ;;
+    *:MSYS*:*)
+        echo ${UNAME_MACHINE}-pc-msys
+        exit ;;
+    i*:windows32*:*)
+        # uname -m includes "-pc" on this system.
+        echo ${UNAME_MACHINE}-mingw32
+        exit ;;
+    i*:PW*:*)
+        echo ${UNAME_MACHINE}-pc-pw32
+        exit ;;
+    *:Interix*:*)
+        case ${UNAME_MACHINE} in
+            x86)
+                echo i586-pc-interix${UNAME_RELEASE}
+                exit ;;
+            authenticamd | genuineintel | EM64T)
+                echo x86_64-unknown-interix${UNAME_RELEASE}
+                exit ;;
+            IA64)
+                echo ia64-unknown-interix${UNAME_RELEASE}
+                exit ;;
+        esac ;;
+    [345]86:Windows_95:* | [345]86:Windows_98:* | [345]86:Windows_NT:*)
+        echo i${UNAME_MACHINE}-pc-mks
+        exit ;;
+:Windows_NT:*)
+        echo x86_64-pc-mks
+        exit ;;
+    i*:Windows_NT*:* | Pentium*:Windows_NT*:*)
+        # How do we know it's Interix rather than the generic POSIX subsystem?
+        # It also conflicts with pre-2.0 versions of AT&T UWIN. Should we
+        # UNAME_MACHINE based on the output of uname instead of i386?
+        echo i586-pc-interix
+        exit ;;
+    i*:UWIN*:*)
+        echo ${UNAME_MACHINE}-pc-uwin
+        exit ;;
+    amd64:CYGWIN*:*:* | x86_64:CYGWIN*:*:*)
+        echo x86_64-unknown-cygwin
+        exit ;;
+    p*:CYGWIN*:*)
+        echo powerpcle-unknown-cygwin
+        exit ;;
+    prep*:SunOS:5.*:*)
+        echo powerpcle-unknown-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'`
+        exit ;;
+    *:GNU:*:*)
+        # the GNU system
+        echo `echo ${UNAME_MACHINE}|sed -e 's,[-/].*$,,'`-unknown-${LIBC}`echo ${UNAME_RELEASE}|sed -e 's,/.*$,,'`
+        exit ;;
+    *:GNU/*:*:*)
+        # other systems with GNU libc and userland
+        echo ${UNAME_MACHINE}-unknown-`echo ${UNAME_SYSTEM} | sed 's,^[^/]*/,,' | tr '[A-Z]' '[a-z]'``echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'`-${LIBC}
+        exit ;;
+    i*86:Minix:*:*)
+        echo ${UNAME_MACHINE}-pc-minix
+        exit ;;
+    aarch64:Linux:*:*)
+        echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
+        exit ;;
+    aarch64_be:Linux:*:*)
+        UNAME_MACHINE=aarch64_be
+        echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
+        exit ;;
+    alpha:Linux:*:*)
+        case `sed -n '/^cpu model/s/^.*: \(.*\)/\1/p' < /proc/cpuinfo` in
+          EV5)   UNAME_MACHINE=alphaev5 ;;
+          EV56)  UNAME_MACHINE=alphaev56 ;;
+          PCA56) UNAME_MACHINE=alphapca56 ;;
+          PCA57) UNAME_MACHINE=alphapca56 ;;
+          EV6)   UNAME_MACHINE=alphaev6 ;;
+          EV67)  UNAME_MACHINE=alphaev67 ;;
+          EV68*) UNAME_MACHINE=alphaev68 ;;
+        esac
+        objdump --private-headers /bin/sh | grep -q ld.so.1
+        if test "$?" = 0 ; then LIBC="gnulibc1" ; fi
+        echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
+        exit ;;
+    arc:Linux:*:* | arceb:Linux:*:*)
+        echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
+        exit ;;
+    arm*:Linux:*:*)
+        eval $set_cc_for_build
+        if echo __ARM_EABI__ | $CC_FOR_BUILD -E - 2>/dev/null \
+            | grep -q __ARM_EABI__
+        then
+            echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
+        else
+            if echo __ARM_PCS_VFP | $CC_FOR_BUILD -E - 2>/dev/null \
+                | grep -q __ARM_PCS_VFP
+            then
+                echo ${UNAME_MACHINE}-unknown-linux-${LIBC}eabi
+            else
+                echo ${UNAME_MACHINE}-unknown-linux-${LIBC}eabihf
+            fi
+        fi
+        exit ;;
+    avr32*:Linux:*:*)
+        echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
+        exit ;;
+    cris:Linux:*:*)
+        echo ${UNAME_MACHINE}-axis-linux-${LIBC}
+        exit ;;
+    crisv32:Linux:*:*)
+        echo ${UNAME_MACHINE}-axis-linux-${LIBC}
+        exit ;;
+    e2k:Linux:*:*)
+        echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
+        exit ;;
+    frv:Linux:*:*)
+        echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
+        exit ;;
+    hexagon:Linux:*:*)
+        echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
+        exit ;;
+    i*86:Linux:*:*)
+        echo ${UNAME_MACHINE}-pc-linux-${LIBC}
+        exit ;;
+    ia64:Linux:*:*)
+        echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
+        exit ;;
+    m32r*:Linux:*:*)
+        echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
+        exit ;;
+    m68*:Linux:*:*)
+        echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
+        exit ;;
+    mips:Linux:*:* | mips64:Linux:*:*)
+        eval $set_cc_for_build
+        sed 's/^        //' << EOF >$dummy.c
+        #undef CPU
+        #undef ${UNAME_MACHINE}
+        #undef ${UNAME_MACHINE}el
+        #if defined(__MIPSEL__) || defined(__MIPSEL) || defined(_MIPSEL) || defined(MIPSEL)
+        CPU=${UNAME_MACHINE}el
+        #else
+        #if defined(__MIPSEB__) || defined(__MIPSEB) || defined(_MIPSEB) || defined(MIPSEB)
+        CPU=${UNAME_MACHINE}
+        #else
+        CPU=
+        #endif
+        #endif
+EOF
+        eval `$CC_FOR_BUILD -E $dummy.c 2>/dev/null | grep '^CPU'`
+        test x"${CPU}" != x && { echo "${CPU}-unknown-linux-${LIBC}"; exit; }
+        ;;
+    openrisc*:Linux:*:*)
+        echo or1k-unknown-linux-${LIBC}
+        exit ;;
+    or32:Linux:*:* | or1k*:Linux:*:*)
+        echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
+        exit ;;
+    padre:Linux:*:*)
+        echo sparc-unknown-linux-${LIBC}
+        exit ;;
+    parisc64:Linux:*:* | hppa64:Linux:*:*)
+        echo hppa64-unknown-linux-${LIBC}
+        exit ;;
+    parisc:Linux:*:* | hppa:Linux:*:*)
+        # Look for CPU level
+        case `grep '^cpu[^a-z]*:' /proc/cpuinfo 2>/dev/null | cut -d' ' -f2` in
+          PA7*) echo hppa1.1-unknown-linux-${LIBC} ;;
+          PA8*) echo hppa2.0-unknown-linux-${LIBC} ;;
+          *)    echo hppa-unknown-linux-${LIBC} ;;
+        esac
+        exit ;;
+    ppc64:Linux:*:*)
+        echo powerpc64-unknown-linux-${LIBC}
+        exit ;;
+    ppc:Linux:*:*)
+        echo powerpc-unknown-linux-${LIBC}
+        exit ;;
+    ppc64le:Linux:*:*)
+        echo powerpc64le-unknown-linux-${LIBC}
+        exit ;;
+    ppcle:Linux:*:*)
+        echo powerpcle-unknown-linux-${LIBC}
+        exit ;;
+    s390:Linux:*:* | s390x:Linux:*:*)
+        echo ${UNAME_MACHINE}-ibm-linux-${LIBC}
+        exit ;;
+    sh64*:Linux:*:*)
+        echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
+        exit ;;
+    sh*:Linux:*:*)
+        echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
+        exit ;;
+    sparc:Linux:*:* | sparc64:Linux:*:*)
+        echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
+        exit ;;
+    tile*:Linux:*:*)
+        echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
+        exit ;;
+    vax:Linux:*:*)
+        echo ${UNAME_MACHINE}-dec-linux-${LIBC}
+        exit ;;
+    x86_64:Linux:*:*)
+        echo ${UNAME_MACHINE}-pc-linux-${LIBC}
+        exit ;;
+    xtensa*:Linux:*:*)
+        echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
+        exit ;;
+    i*86:DYNIX/ptx:4*:*)
+        # ptx 4.0 does uname -s correctly, with DYNIX/ptx in there.
+        # earlier versions are messed up and put the nodename in both
+        # sysname and nodename.
+        echo i386-sequent-sysv4
+        exit ;;
+    i*86:UNIX_SV:4.2MP:2.*)
+        # Unixware is an offshoot of SVR4, but it has its own version
+        # number series starting with 2...
+        # I am not positive that other SVR4 systems won't match this,
+        # I just have to hope.  -- rms.
+        # Use sysv4.2uw... so that sysv4* matches it.
+        echo ${UNAME_MACHINE}-pc-sysv4.2uw${UNAME_VERSION}
+        exit ;;
+    i*86:OS/2:*:*)
+        # If we were able to find `uname', then EMX Unix compatibility
+        # is probably installed.
+        echo ${UNAME_MACHINE}-pc-os2-emx
+        exit ;;
+    i*86:XTS-300:*:STOP)
+        echo ${UNAME_MACHINE}-unknown-stop
+        exit ;;
+    i*86:atheos:*:*)
+        echo ${UNAME_MACHINE}-unknown-atheos
+        exit ;;
+    i*86:syllable:*:*)
+        echo ${UNAME_MACHINE}-pc-syllable
+        exit ;;
+    i*86:LynxOS:2.*:* | i*86:LynxOS:3.[01]*:* | i*86:LynxOS:4.[02]*:*)
+        echo i386-unknown-lynxos${UNAME_RELEASE}
+        exit ;;
+    i*86:*DOS:*:*)
+        echo ${UNAME_MACHINE}-pc-msdosdjgpp
+        exit ;;
+    i*86:*:4.*:* | i*86:SYSTEM_V:4.*:*)
+        UNAME_REL=`echo ${UNAME_RELEASE} | sed 's/\/MP$//'`
+        if grep Novell /usr/include/link.h >/dev/null 2>/dev/null; then
+                echo ${UNAME_MACHINE}-univel-sysv${UNAME_REL}
+        else
+                echo ${UNAME_MACHINE}-pc-sysv${UNAME_REL}
+        fi
+        exit ;;
+    i*86:*:5:[678]*)
+        # UnixWare 7.x, OpenUNIX and OpenServer 6.
+        case `/bin/uname -X | grep "^Machine"` in
+            *486*)           UNAME_MACHINE=i486 ;;
+            *Pentium)        UNAME_MACHINE=i586 ;;
+            *Pent*|*Celeron) UNAME_MACHINE=i686 ;;
+        esac
+        echo ${UNAME_MACHINE}-unknown-sysv${UNAME_RELEASE}${UNAME_SYSTEM}${UNAME_VERSION}
+        exit ;;
+    i*86:*:3.2:*)
+        if test -f /usr/options/cb.name; then
+                UNAME_REL=`sed -n 's/.*Version //p' </usr/options/cb.name`
+                echo ${UNAME_MACHINE}-pc-isc$UNAME_REL
+        elif /bin/uname -X 2>/dev/null >/dev/null ; then
+                UNAME_REL=`(/bin/uname -X|grep Release|sed -e 's/.*= //')`
+                (/bin/uname -X|grep i80486 >/dev/null) && UNAME_MACHINE=i486
+                (/bin/uname -X|grep '^Machine.*Pentium' >/dev/null) \
+                        && UNAME_MACHINE=i586
+                (/bin/uname -X|grep '^Machine.*Pent *II' >/dev/null) \
+                        && UNAME_MACHINE=i686
+                (/bin/uname -X|grep '^Machine.*Pentium Pro' >/dev/null) \
+                        && UNAME_MACHINE=i686
+                echo ${UNAME_MACHINE}-pc-sco$UNAME_REL
+        else
+                echo ${UNAME_MACHINE}-pc-sysv32
+        fi
+        exit ;;
+    pc:*:*:*)
+        # Left here for compatibility:
+        # uname -m prints for DJGPP always 'pc', but it prints nothing about
+        # the processor, so we play safe by assuming i586.
+        # Note: whatever this is, it MUST be the same as what config.sub
+        # prints for the "djgpp" host, or else GDB configury will decide that
+        # this is a cross-build.
+        echo i586-pc-msdosdjgpp
+        exit ;;
+    Intel:Mach:3*:*)
+        echo i386-pc-mach3
+        exit ;;
+    paragon:*:*:*)
+        echo i860-intel-osf1
+        exit ;;
+    i860:*:4.*:*) # i860-SVR4
+        if grep Stardent /usr/include/sys/uadmin.h >/dev/null 2>&1 ; then
+          echo i860-stardent-sysv${UNAME_RELEASE} # Stardent Vistra i860-SVR4
+        else # Add other i860-SVR4 vendors below as they are discovered.
+          echo i860-unknown-sysv${UNAME_RELEASE}  # Unknown i860-SVR4
+        fi
+        exit ;;
+    mini*:CTIX:SYS*5:*)
+        # "miniframe"
+        echo m68010-convergent-sysv
+        exit ;;
+    mc68k:UNIX:SYSTEM5:3.51m)
+        echo m68k-convergent-sysv
+        exit ;;
+    M680?0:D-NIX:5.3:*)
+        echo m68k-diab-dnix
+        exit ;;
+    M68*:*:R3V[5678]*:*)
+        test -r /sysV68 && { echo 'm68k-motorola-sysv'; exit; } ;;
+[345]??:*:4.0:3.0 | 3[34]??A:*:4.0:3.0 | 3[34]??,*:*:4.0:3.0 | 3[34]??/*:*:4.0:3.0 | 4400:*:4.0:3.0 | 4850:*:4.0:3.0 | SKA40:*:4.0:3.0 | SDS2:*:4.0:3.0 | SHG2:*:4.0:3.0 | S7501*:*:4.0:3.0)
+        OS_REL=''
+        test -r /etc/.relid \
+        && OS_REL=.`sed -n 's/[^ ]* [^ ]* \([0-9][0-9]\).*/\1/p' < /etc/.relid`
+        /bin/uname -p 2>/dev/null | grep 86 >/dev/null \
+          && { echo i486-ncr-sysv4.3${OS_REL}; exit; }
+        /bin/uname -p 2>/dev/null | /bin/grep entium >/dev/null \
+          && { echo i586-ncr-sysv4.3${OS_REL}; exit; } ;;
+[34]??:*:4.0:* | 3[34]??,*:*:4.0:*)
+        /bin/uname -p 2>/dev/null | grep 86 >/dev/null \
+          && { echo i486-ncr-sysv4; exit; } ;;
+    NCR*:*:4.2:* | MPRAS*:*:4.2:*)
+        OS_REL='.3'
+        test -r /etc/.relid \
+            && OS_REL=.`sed -n 's/[^ ]* [^ ]* \([0-9][0-9]\).*/\1/p' < /etc/.relid`
+        /bin/uname -p 2>/dev/null | grep 86 >/dev/null \
+            && { echo i486-ncr-sysv4.3${OS_REL}; exit; }
+        /bin/uname -p 2>/dev/null | /bin/grep entium >/dev/null \
+            && { echo i586-ncr-sysv4.3${OS_REL}; exit; }
+        /bin/uname -p 2>/dev/null | /bin/grep pteron >/dev/null \
+            && { echo i586-ncr-sysv4.3${OS_REL}; exit; } ;;
+    m68*:LynxOS:2.*:* | m68*:LynxOS:3.0*:*)
+        echo m68k-unknown-lynxos${UNAME_RELEASE}
+        exit ;;
+    mc68030:UNIX_System_V:4.*:*)
+        echo m68k-atari-sysv4
+        exit ;;
+    TSUNAMI:LynxOS:2.*:*)
+        echo sparc-unknown-lynxos${UNAME_RELEASE}
+        exit ;;
+    rs6000:LynxOS:2.*:*)
+        echo rs6000-unknown-lynxos${UNAME_RELEASE}
+        exit ;;
+    PowerPC:LynxOS:2.*:* | PowerPC:LynxOS:3.[01]*:* | PowerPC:LynxOS:4.[02]*:*)
+        echo powerpc-unknown-lynxos${UNAME_RELEASE}
+        exit ;;
+    SM[BE]S:UNIX_SV:*:*)
+        echo mips-dde-sysv${UNAME_RELEASE}
+        exit ;;
+    RM*:ReliantUNIX-*:*:*)
+        echo mips-sni-sysv4
+        exit ;;
+    RM*:SINIX-*:*:*)
+        echo mips-sni-sysv4
+        exit ;;
+    *:SINIX-*:*:*)
+        if uname -p 2>/dev/null >/dev/null ; then
+                UNAME_MACHINE=`(uname -p) 2>/dev/null`
+                echo ${UNAME_MACHINE}-sni-sysv4
+        else
+                echo ns32k-sni-sysv
+        fi
+        exit ;;
+    PENTIUM:*:4.0*:*)   # Unisys `ClearPath HMP IX 4000' SVR4/MP effort
+                        # says <Richard.M.Bartel@ccMail.Census.GOV>
+        echo i586-unisys-sysv4
+        exit ;;
+    *:UNIX_System_V:4*:FTX*)
+        # From Gerald Hewes <hewes@openmarket.com>.
+        # How about differentiating between stratus architectures? -djm
+        echo hppa1.1-stratus-sysv4
+        exit ;;
+    *:*:*:FTX*)
+        # From seanf@swdc.stratus.com.
+        echo i860-stratus-sysv4
+        exit ;;
+    i*86:VOS:*:*)
+        # From Paul.Green@stratus.com.
+        echo ${UNAME_MACHINE}-stratus-vos
+        exit ;;
+    *:VOS:*:*)
+        # From Paul.Green@stratus.com.
+        echo hppa1.1-stratus-vos
+        exit ;;
+    mc68*:A/UX:*:*)
+        echo m68k-apple-aux${UNAME_RELEASE}
+        exit ;;
+    news*:NEWS-OS:6*:*)
+        echo mips-sony-newsos6
+        exit ;;
+    R[34]000:*System_V*:*:* | R4000:UNIX_SYSV:*:* | R*000:UNIX_SV:*:*)
+        if [ -d /usr/nec ]; then
+                echo mips-nec-sysv${UNAME_RELEASE}
+        else
+                echo mips-unknown-sysv${UNAME_RELEASE}
+        fi
+        exit ;;
+    BeBox:BeOS:*:*)     # BeOS running on hardware made by Be, PPC only.
+        echo powerpc-be-beos
+        exit ;;
+    BeMac:BeOS:*:*)     # BeOS running on Mac or Mac clone, PPC only.
+        echo powerpc-apple-beos
+        exit ;;
+    BePC:BeOS:*:*)      # BeOS running on Intel PC compatible.
+        echo i586-pc-beos
+        exit ;;
+    BePC:Haiku:*:*)     # Haiku running on Intel PC compatible.
+        echo i586-pc-haiku
+        exit ;;
+    x86_64:Haiku:*:*)
+        echo x86_64-unknown-haiku
+        exit ;;
+    SX-4:SUPER-UX:*:*)
+        echo sx4-nec-superux${UNAME_RELEASE}
+        exit ;;
+    SX-5:SUPER-UX:*:*)
+        echo sx5-nec-superux${UNAME_RELEASE}
+        exit ;;
+    SX-6:SUPER-UX:*:*)
+        echo sx6-nec-superux${UNAME_RELEASE}
+        exit ;;
+    SX-7:SUPER-UX:*:*)
+        echo sx7-nec-superux${UNAME_RELEASE}
+        exit ;;
+    SX-8:SUPER-UX:*:*)
+        echo sx8-nec-superux${UNAME_RELEASE}
+        exit ;;
+    SX-8R:SUPER-UX:*:*)
+        echo sx8r-nec-superux${UNAME_RELEASE}
+        exit ;;
+    Power*:Rhapsody:*:*)
+        echo powerpc-apple-rhapsody${UNAME_RELEASE}
+        exit ;;
+    *:Rhapsody:*:*)
+        echo ${UNAME_MACHINE}-apple-rhapsody${UNAME_RELEASE}
+        exit ;;
+    *:Darwin:*:*)
+        UNAME_PROCESSOR=`uname -p` || UNAME_PROCESSOR=unknown
+        eval $set_cc_for_build
+        if test "$UNAME_PROCESSOR" = unknown ; then
+            UNAME_PROCESSOR=powerpc
+        fi
+        if test `echo "$UNAME_RELEASE" | sed -e 's/\..*//'` -le 10 ; then
+            if [ "$CC_FOR_BUILD" != 'no_compiler_found' ]; then
+                if (echo '#ifdef __LP64__'; echo IS_64BIT_ARCH; echo '#endif') | \
+                    (CCOPTS= $CC_FOR_BUILD -E - 2>/dev/null) | \
+                    grep IS_64BIT_ARCH >/dev/null
+                then
+                    case $UNAME_PROCESSOR in
+                        i386) UNAME_PROCESSOR=x86_64 ;;
+                        powerpc) UNAME_PROCESSOR=powerpc64 ;;
+                    esac
+                fi
+            fi
+        elif test "$UNAME_PROCESSOR" = i386 ; then
+            # Avoid executing cc on OS X 10.9, as it ships with a stub
+            # that puts up a graphical alert prompting to install
+            # developer tools.  Any system running Mac OS X 10.7 or
+            # later (Darwin 11 and later) is required to have a 64-bit
+            # processor. This is not true of the ARM version of Darwin
+            # that Apple uses in portable devices.
+            UNAME_PROCESSOR=x86_64
+        fi
+        echo ${UNAME_PROCESSOR}-apple-darwin${UNAME_RELEASE}
+        exit ;;
+    *:procnto*:*:* | *:QNX:[0123456789]*:*)
+        UNAME_PROCESSOR=`uname -p`
+        if test "$UNAME_PROCESSOR" = "x86"; then
+                UNAME_PROCESSOR=i386
+                UNAME_MACHINE=pc
+        fi
+        echo ${UNAME_PROCESSOR}-${UNAME_MACHINE}-nto-qnx${UNAME_RELEASE}
+        exit ;;
+    *:QNX:*:4*)
+        echo i386-pc-qnx
+        exit ;;
+    NEO-?:NONSTOP_KERNEL:*:*)
+        echo neo-tandem-nsk${UNAME_RELEASE}
+        exit ;;
+    NSE-*:NONSTOP_KERNEL:*:*)
+        echo nse-tandem-nsk${UNAME_RELEASE}
+        exit ;;
+    NSR-?:NONSTOP_KERNEL:*:*)
+        echo nsr-tandem-nsk${UNAME_RELEASE}
+        exit ;;
+    *:NonStop-UX:*:*)
+        echo mips-compaq-nonstopux
+        exit ;;
+    BS2000:POSIX*:*:*)
+        echo bs2000-siemens-sysv
+        exit ;;
+    DS/*:UNIX_System_V:*:*)
+        echo ${UNAME_MACHINE}-${UNAME_SYSTEM}-${UNAME_RELEASE}
+        exit ;;
+    *:Plan9:*:*)
+        # "uname -m" is not consistent, so use $cputype instead. 386
+        # is converted to i386 for consistency with other x86
+        # operating systems.
+        if test "$cputype" = "386"; then
+            UNAME_MACHINE=i386
+        else
+            UNAME_MACHINE="$cputype"
+        fi
+        echo ${UNAME_MACHINE}-unknown-plan9
+        exit ;;
+    *:TOPS-10:*:*)
+        echo pdp10-unknown-tops10
+        exit ;;
+    *:TENEX:*:*)
+        echo pdp10-unknown-tenex
+        exit ;;
+    KS10:TOPS-20:*:* | KL10:TOPS-20:*:* | TYPE4:TOPS-20:*:*)
+        echo pdp10-dec-tops20
+        exit ;;
+    XKL-1:TOPS-20:*:* | TYPE5:TOPS-20:*:*)
+        echo pdp10-xkl-tops20
+        exit ;;
+    *:TOPS-20:*:*)
+        echo pdp10-unknown-tops20
+        exit ;;
+    *:ITS:*:*)
+        echo pdp10-unknown-its
+        exit ;;
+    SEI:*:*:SEIUX)
+        echo mips-sei-seiux${UNAME_RELEASE}
+        exit ;;
+    *:DragonFly:*:*)
+        echo ${UNAME_MACHINE}-unknown-dragonfly`echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'`
+        exit ;;
+    *:*VMS:*:*)
+        UNAME_MACHINE=`(uname -p) 2>/dev/null`
+        case "${UNAME_MACHINE}" in
+            A*) echo alpha-dec-vms ; exit ;;
+            I*) echo ia64-dec-vms ; exit ;;
+            V*) echo vax-dec-vms ; exit ;;
+        esac ;;
+    *:XENIX:*:SysV)
+        echo i386-pc-xenix
+        exit ;;
+    i*86:skyos:*:*)
+        echo ${UNAME_MACHINE}-pc-skyos`echo ${UNAME_RELEASE}` | sed -e 's/ .*$//'
+        exit ;;
+    i*86:rdos:*:*)
+        echo ${UNAME_MACHINE}-pc-rdos
+        exit ;;
+    i*86:AROS:*:*)
+        echo ${UNAME_MACHINE}-pc-aros
+        exit ;;
+    x86_64:VMkernel:*:*)
+        echo ${UNAME_MACHINE}-unknown-esx
+        exit ;;
+esac
+cat >&2 <<EOF
+$0: unable to guess system type
+This script, last modified $timestamp, has failed to recognize
+the operating system you are using. It is advised that you
+download the most up to date version of the config scripts from
+  http://git.savannah.gnu.org/gitweb/?p=config.git;a=blob_plain;f=config.guess;hb=HEAD
+and
+  http://git.savannah.gnu.org/gitweb/?p=config.git;a=blob_plain;f=config.sub;hb=HEAD
+If the version you run ($0) is already up to date, please
+send the following data and any information you think might be
+pertinent to <config-patches@gnu.org> in order to provide the needed
+information to handle your system.
+config.guess timestamp = $timestamp
+uname -m = `(uname -m) 2>/dev/null || echo unknown`
+uname -r = `(uname -r) 2>/dev/null || echo unknown`
+uname -s = `(uname -s) 2>/dev/null || echo unknown`
+uname -v = `(uname -v) 2>/dev/null || echo unknown`
+/usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null`
+/bin/uname -X     = `(/bin/uname -X) 2>/dev/null`
+hostinfo               = `(hostinfo) 2>/dev/null`
+/bin/universe          = `(/bin/universe) 2>/dev/null`
+/usr/bin/arch -k       = `(/usr/bin/arch -k) 2>/dev/null`
+/bin/arch              = `(/bin/arch) 2>/dev/null`
+/usr/bin/oslevel       = `(/usr/bin/oslevel) 2>/dev/null`
+/usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null`
+UNAME_MACHINE = ${UNAME_MACHINE}
+UNAME_RELEASE = ${UNAME_RELEASE}
+UNAME_SYSTEM  = ${UNAME_SYSTEM}
+UNAME_VERSION = ${UNAME_VERSION}
+EOF
+exit 1
+# Local variables:
+# eval: (add-hook 'write-file-hooks 'time-stamp)
+# time-stamp-start: "timestamp='"
+# time-stamp-format: "%:y-%02m-%02d"
+# time-stamp-end: "'"
+# End:
+/usr/share/automake-1.15/config.guess

automake/config.sub

Property mode changed from 100755 to 120000

-              r0720e049
+              r3d4b23fa
+#! /bin/sh
+# Configuration validation subroutine script.
+#   Copyright 1992-2015 Free Software Foundation, Inc.
+timestamp='2015-08-20'
+# This file is free software; you can redistribute it and/or modify it
+# under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, see <http://www.gnu.org/licenses/>.
+#
+# As a special exception to the GNU General Public License, if you
+# distribute this file as part of a program that contains a
+# configuration script generated by Autoconf, you may include it under
+# the same distribution terms that you use for the rest of that
+# program.  This Exception is an additional permission under section 7
+# of the GNU General Public License, version 3 ("GPLv3").
+# Please send patches to <config-patches@gnu.org>.
+#
+# Configuration subroutine to validate and canonicalize a configuration type.
+# Supply the specified configuration type as an argument.
+# If it is invalid, we print an error message on stderr and exit with code 1.
+# Otherwise, we print the canonical config type on stdout and succeed.
+# You can get the latest version of this script from:
+# http://git.savannah.gnu.org/gitweb/?p=config.git;a=blob_plain;f=config.sub;hb=HEAD
+# This file is supposed to be the same for all GNU packages
+# and recognize all the CPU types, system types and aliases
+# that are meaningful with *any* GNU software.
+# Each package is responsible for reporting which valid configurations
+# it does not support.  The user should be able to distinguish
+# a failure to support a valid configuration from a meaningless
+# configuration.
+# The goal of this file is to map all the various variations of a given
+# machine specification into a single specification in the form:
+#       CPU_TYPE-MANUFACTURER-OPERATING_SYSTEM
+# or in some cases, the newer four-part form:
+#       CPU_TYPE-MANUFACTURER-KERNEL-OPERATING_SYSTEM
+# It is wrong to echo any other type of specification.
+me=`echo "$0" | sed -e 's,.*/,,'`
+usage="\
+Usage: $0 [OPTION] CPU-MFR-OPSYS
+       $0 [OPTION] ALIAS
+Canonicalize a configuration name.
+Operation modes:
+  -h, --help         print this help, then exit
+  -t, --time-stamp   print date of last modification, then exit
+  -v, --version      print version number, then exit
+Report bugs and patches to <config-patches@gnu.org>."
+version="\
+GNU config.sub ($timestamp)
+Copyright 1992-2015 Free Software Foundation, Inc.
+This is free software; see the source for copying conditions.  There is NO
+warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE."
+help="
+Try \`$me --help' for more information."
+# Parse command line
+while test $# -gt 0 ; do
+  case $1 in
+    --time-stamp | --time* | -t )
+       echo "$timestamp" ; exit ;;
+    --version | -v )
+       echo "$version" ; exit ;;
+    --help | --h* | -h )
+       echo "$usage"; exit ;;
+    -- )     # Stop option processing
+       shift; break ;;
+    - ) # Use stdin as input.
+       break ;;
+    -* )
+       echo "$me: invalid option $1$help"
+       exit 1 ;;
+    *local*)
+       # First pass through any local machine types.
+       echo $1
+       exit ;;
+    * )
+       break ;;
+  esac
+done
+case $# in
+) echo "$me: missing argument$help" >&2
+    exit 1;;
+) ;;
+ *) echo "$me: too many arguments$help" >&2
+    exit 1;;
+esac
+# Separate what the user gave into CPU-COMPANY and OS or KERNEL-OS (if any).
+# Here we must recognize all the valid KERNEL-OS combinations.
+maybe_os=`echo $1 | sed 's/^\(.*\)-\([^-]*-[^-]*\)$/\2/'`
+case $maybe_os in
+  nto-qnx* | linux-gnu* | linux-android* | linux-dietlibc | linux-newlib* | \
+  linux-musl* | linux-uclibc* | uclinux-uclibc* | uclinux-gnu* | kfreebsd*-gnu* | \
+  knetbsd*-gnu* | netbsd*-gnu* | netbsd*-eabi* | \
+  kopensolaris*-gnu* | \
+  storm-chaos* | os2-emx* | rtmk-nova*)
+    os=-$maybe_os
+    basic_machine=`echo $1 | sed 's/^\(.*\)-\([^-]*-[^-]*\)$/\1/'`
+    ;;
+  android-linux)
+    os=-linux-android
+    basic_machine=`echo $1 | sed 's/^\(.*\)-\([^-]*-[^-]*\)$/\1/'`-unknown
+    ;;
+  *)
+    basic_machine=`echo $1 | sed 's/-[^-]*$//'`
+    if [ $basic_machine != $1 ]
+    then os=`echo $1 | sed 's/.*-/-/'`
+    else os=; fi
+    ;;
+esac
+### Let's recognize common machines as not being operating systems so
+### that things like config.sub decstation-3100 work.  We also
+### recognize some manufacturers as not being operating systems, so we
+### can provide default operating systems below.
+case $os in
+        -sun*os*)
+                # Prevent following clause from handling this invalid input.
+                ;;
+        -dec* | -mips* | -sequent* | -encore* | -pc532* | -sgi* | -sony* | \
+        -att* | -7300* | -3300* | -delta* | -motorola* | -sun[234]* | \
+        -unicom* | -ibm* | -next | -hp | -isi* | -apollo | -altos* | \
+        -convergent* | -ncr* | -news | -32* | -3600* | -3100* | -hitachi* |\
+        -c[123]* | -convex* | -sun | -crds | -omron* | -dg | -ultra | -tti* | \
+        -harris | -dolphin | -highlevel | -gould | -cbm | -ns | -masscomp | \
+        -apple | -axis | -knuth | -cray | -microblaze*)
+                os=
+                basic_machine=$1
+                ;;
+        -bluegene*)
+                os=-cnk
+                ;;
+        -sim | -cisco | -oki | -wec | -winbond)
+                os=
+                basic_machine=$1
+                ;;
+        -scout)
+                ;;
+        -wrs)
+                os=-vxworks
+                basic_machine=$1
+                ;;
+        -chorusos*)
+                os=-chorusos
+                basic_machine=$1
+                ;;
+        -chorusrdb)
+                os=-chorusrdb
+                basic_machine=$1
+                ;;
+        -hiux*)
+                os=-hiuxwe2
+                ;;
+        -sco6)
+                os=-sco5v6
+                basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`
+                ;;
+        -sco5)
+                os=-sco3.2v5
+                basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`
+                ;;
+        -sco4)
+                os=-sco3.2v4
+                basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`
+                ;;
+        -sco3.2.[4-9]*)
+                os=`echo $os | sed -e 's/sco3.2./sco3.2v/'`
+                basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`
+                ;;
+        -sco3.2v[4-9]*)
+                # Don't forget version if it is 3.2v4 or newer.
+                basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`
+                ;;
+        -sco5v6*)
+                # Don't forget version if it is 3.2v4 or newer.
+                basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`
+                ;;
+        -sco*)
+                os=-sco3.2v2
+                basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`
+                ;;
+        -udk*)
+                basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`
+                ;;
+        -isc)
+                os=-isc2.2
+                basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`
+                ;;
+        -clix*)
+                basic_machine=clipper-intergraph
+                ;;
+        -isc*)
+                basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`
+                ;;
+        -lynx*178)
+                os=-lynxos178
+                ;;
+        -lynx*5)
+                os=-lynxos5
+                ;;
+        -lynx*)
+                os=-lynxos
+                ;;
+        -ptx*)
+                basic_machine=`echo $1 | sed -e 's/86-.*/86-sequent/'`
+                ;;
+        -windowsnt*)
+                os=`echo $os | sed -e 's/windowsnt/winnt/'`
+                ;;
+        -psos*)
+                os=-psos
+                ;;
+        -mint | -mint[0-9]*)
+                basic_machine=m68k-atari
+                os=-mint
+                ;;
+esac
+# Decode aliases for certain CPU-COMPANY combinations.
+case $basic_machine in
+        # Recognize the basic CPU types without company name.
+        # Some are omitted here because they have special meanings below.
+a | 580 \
+        | a29k \
+        | aarch64 | aarch64_be \
+        | alpha | alphaev[4-8] | alphaev56 | alphaev6[78] | alphapca5[67] \
+        | alpha64 | alpha64ev[4-8] | alpha64ev56 | alpha64ev6[78] | alpha64pca5[67] \
+        | am33_2.0 \
+        | arc | arceb \
+        | arm | arm[bl]e | arme[lb] | armv[2-8] | armv[3-8][lb] | armv7[arm] \
+        | avr | avr32 \
+        | ba \
+        | be32 | be64 \
+        | bfin \
+        | c4x | c8051 | clipper \
+        | d10v | d30v | dlx | dsp16xx \
+        | e2k | epiphany \
+        | fido | fr30 | frv | ft32 \
+        | h8300 | h8500 | hppa | hppa1.[01] | hppa2.0 | hppa2.0[nw] | hppa64 \
+        | hexagon \
+        | i370 | i860 | i960 | ia64 \
+        | ip2k | iq2000 \
+        | k1om \
+        | le32 | le64 \
+        | lm32 \
+        | m32c | m32r | m32rle | m68000 | m68k | m88k \
+        | maxq | mb | microblaze | microblazeel | mcore | mep | metag \
+        | mips | mipsbe | mipseb | mipsel | mipsle \
+        | mips16 \
+        | mips64 | mips64el \
+        | mips64octeon | mips64octeonel \
+        | mips64orion | mips64orionel \
+        | mips64r5900 | mips64r5900el \
+        | mips64vr | mips64vrel \
+        | mips64vr4100 | mips64vr4100el \
+        | mips64vr4300 | mips64vr4300el \
+        | mips64vr5000 | mips64vr5000el \
+        | mips64vr5900 | mips64vr5900el \
+        | mipsisa32 | mipsisa32el \
+        | mipsisa32r2 | mipsisa32r2el \
+        | mipsisa32r6 | mipsisa32r6el \
+        | mipsisa64 | mipsisa64el \
+        | mipsisa64r2 | mipsisa64r2el \
+        | mipsisa64r6 | mipsisa64r6el \
+        | mipsisa64sb1 | mipsisa64sb1el \
+        | mipsisa64sr71k | mipsisa64sr71kel \
+        | mipsr5900 | mipsr5900el \
+        | mipstx39 | mipstx39el \
+        | mn10200 | mn10300 \
+        | moxie \
+        | mt \
+        | msp430 \
+        | nds32 | nds32le | nds32be \
+        | nios | nios2 | nios2eb | nios2el \
+        | ns16k | ns32k \
+        | open8 | or1k | or1knd | or32 \
+        | pdp10 | pdp11 | pj | pjl \
+        | powerpc | powerpc64 | powerpc64le | powerpcle \
+        | pyramid \
+        | riscv32 | riscv64 \
+        | rl78 | rx \
+        | score \
+        | sh | sh[1234] | sh[24]a | sh[24]aeb | sh[23]e | sh[234]eb | sheb | shbe | shle | sh[1234]le | sh3ele \
+        | sh64 | sh64le \
+        | sparc | sparc64 | sparc64b | sparc64v | sparc86x | sparclet | sparclite \
+        | sparcv8 | sparcv9 | sparcv9b | sparcv9v \
+        | spu \
+        | tahoe | tic4x | tic54x | tic55x | tic6x | tic80 | tron \
+        | ubicom32 \
+        | v850 | v850e | v850e1 | v850e2 | v850es | v850e2v3 \
+        | visium \
+        | we32k \
+        | x86 | xc16x | xstormy16 | xtensa \
+        | z8k | z80)
+                basic_machine=$basic_machine-unknown
+                ;;
+        c54x)
+                basic_machine=tic54x-unknown
+                ;;
+        c55x)
+                basic_machine=tic55x-unknown
+                ;;
+        c6x)
+                basic_machine=tic6x-unknown
+                ;;
+        leon|leon[3-9])
+                basic_machine=sparc-$basic_machine
+                ;;
+        m6811 | m68hc11 | m6812 | m68hc12 | m68hcs12x | nvptx | picochip)
+                basic_machine=$basic_machine-unknown
+                os=-none
+                ;;
+        m88110 | m680[12346]0 | m683?2 | m68360 | m5200 | v70 | w65 | z8k)
+                ;;
+        ms1)
+                basic_machine=mt-unknown
+                ;;
+        strongarm | thumb | xscale)
+                basic_machine=arm-unknown
+                ;;
+        xgate)
+                basic_machine=$basic_machine-unknown
+                os=-none
+                ;;
+        xscaleeb)
+                basic_machine=armeb-unknown
+                ;;
+        xscaleel)
+                basic_machine=armel-unknown
+                ;;
+        # We use `pc' rather than `unknown'
+        # because (1) that's what they normally are, and
+        # (2) the word "unknown" tends to confuse beginning users.
+        i*86 | x86_64)
+          basic_machine=$basic_machine-pc
+          ;;
+        # Object if more than one company name word.
+        *-*-*)
+                echo Invalid configuration \`$1\': machine \`$basic_machine\' not recognized 1>&2
+                exit 1
+                ;;
+        # Recognize the basic CPU types with company name.
+-* \
+        | a29k-* \
+        | aarch64-* | aarch64_be-* \
+        | alpha-* | alphaev[4-8]-* | alphaev56-* | alphaev6[78]-* \
+        | alpha64-* | alpha64ev[4-8]-* | alpha64ev56-* | alpha64ev6[78]-* \
+        | alphapca5[67]-* | alpha64pca5[67]-* | arc-* | arceb-* \
+        | arm-*  | armbe-* | armle-* | armeb-* | armv*-* \
+        | avr-* | avr32-* \
+        | ba-* \
+        | be32-* | be64-* \
+        | bfin-* | bs2000-* \
+        | c[123]* | c30-* | [cjt]90-* | c4x-* \
+        | c8051-* | clipper-* | craynv-* | cydra-* \
+        | d10v-* | d30v-* | dlx-* \
+        | e2k-* | elxsi-* \
+        | f30[01]-* | f700-* | fido-* | fr30-* | frv-* | fx80-* \
+        | h8300-* | h8500-* \
+        | hppa-* | hppa1.[01]-* | hppa2.0-* | hppa2.0[nw]-* | hppa64-* \
+        | hexagon-* \
+        | i*86-* | i860-* | i960-* | ia64-* \
+        | ip2k-* | iq2000-* \
+        | k1om-* \
+        | le32-* | le64-* \
+        | lm32-* \
+        | m32c-* | m32r-* | m32rle-* \
+        | m68000-* | m680[012346]0-* | m68360-* | m683?2-* | m68k-* \
+        | m88110-* | m88k-* | maxq-* | mcore-* | metag-* \
+        | microblaze-* | microblazeel-* \
+        | mips-* | mipsbe-* | mipseb-* | mipsel-* | mipsle-* \
+        | mips16-* \
+        | mips64-* | mips64el-* \
+        | mips64octeon-* | mips64octeonel-* \
+        | mips64orion-* | mips64orionel-* \
+        | mips64r5900-* | mips64r5900el-* \
+        | mips64vr-* | mips64vrel-* \
+        | mips64vr4100-* | mips64vr4100el-* \
+        | mips64vr4300-* | mips64vr4300el-* \
+        | mips64vr5000-* | mips64vr5000el-* \
+        | mips64vr5900-* | mips64vr5900el-* \
+        | mipsisa32-* | mipsisa32el-* \
+        | mipsisa32r2-* | mipsisa32r2el-* \
+        | mipsisa32r6-* | mipsisa32r6el-* \
+        | mipsisa64-* | mipsisa64el-* \
+        | mipsisa64r2-* | mipsisa64r2el-* \
+        | mipsisa64r6-* | mipsisa64r6el-* \
+        | mipsisa64sb1-* | mipsisa64sb1el-* \
+        | mipsisa64sr71k-* | mipsisa64sr71kel-* \
+        | mipsr5900-* | mipsr5900el-* \
+        | mipstx39-* | mipstx39el-* \
+        | mmix-* \
+        | mt-* \
+        | msp430-* \
+        | nds32-* | nds32le-* | nds32be-* \
+        | nios-* | nios2-* | nios2eb-* | nios2el-* \
+        | none-* | np1-* | ns16k-* | ns32k-* \
+        | open8-* \
+        | or1k*-* \
+        | orion-* \
+        | pdp10-* | pdp11-* | pj-* | pjl-* | pn-* | power-* \
+        | powerpc-* | powerpc64-* | powerpc64le-* | powerpcle-* \
+        | pyramid-* \
+        | riscv32-* | riscv64-* \
+        | rl78-* | romp-* | rs6000-* | rx-* \
+        | sh-* | sh[1234]-* | sh[24]a-* | sh[24]aeb-* | sh[23]e-* | sh[34]eb-* | sheb-* | shbe-* \
+        | shle-* | sh[1234]le-* | sh3ele-* | sh64-* | sh64le-* \
+        | sparc-* | sparc64-* | sparc64b-* | sparc64v-* | sparc86x-* | sparclet-* \
+        | sparclite-* \
+        | sparcv8-* | sparcv9-* | sparcv9b-* | sparcv9v-* | sv1-* | sx*-* \
+        | tahoe-* \
+        | tic30-* | tic4x-* | tic54x-* | tic55x-* | tic6x-* | tic80-* \
+        | tile*-* \
+        | tron-* \
+        | ubicom32-* \
+        | v850-* | v850e-* | v850e1-* | v850es-* | v850e2-* | v850e2v3-* \
+        | vax-* \
+        | visium-* \
+        | we32k-* \
+        | x86-* | x86_64-* | xc16x-* | xps100-* \
+        | xstormy16-* | xtensa*-* \
+        | ymp-* \
+        | z8k-* | z80-*)
+                ;;
+        # Recognize the basic CPU types without company name, with glob match.
+        xtensa*)
+                basic_machine=$basic_machine-unknown
+                ;;
+        # Recognize the various machine names and aliases which stand
+        # for a CPU type and a company and sometimes even an OS.
+bsd)
+                basic_machine=i386-unknown
+                os=-bsd
+                ;;
+b1 | 7300 | 7300-att | att-7300 | pc7300 | safari | unixpc)
+                basic_machine=m68000-att
+                ;;
+b*)
+                basic_machine=we32k-att
+                ;;
+        a29khif)
+                basic_machine=a29k-amd
+                os=-udi
+                ;;
+        abacus)
+                basic_machine=abacus-unknown
+                ;;
+        adobe68k)
+                basic_machine=m68010-adobe
+                os=-scout
+                ;;
+        alliant | fx80)
+                basic_machine=fx80-alliant
+                ;;
+        altos | altos3068)
+                basic_machine=m68k-altos
+                ;;
+        am29k)
+                basic_machine=a29k-none
+                os=-bsd
+                ;;
+        amd64)
+                basic_machine=x86_64-pc
+                ;;
+        amd64-*)
+                basic_machine=x86_64-`echo $basic_machine | sed 's/^[^-]*-//'`
+                ;;
+        amdahl)
+                basic_machine=580-amdahl
+                os=-sysv
+                ;;
+        amiga | amiga-*)
+                basic_machine=m68k-unknown
+                ;;
+        amigaos | amigados)
+                basic_machine=m68k-unknown
+                os=-amigaos
+                ;;
+        amigaunix | amix)
+                basic_machine=m68k-unknown
+                os=-sysv4
+                ;;
+        apollo68)
+                basic_machine=m68k-apollo
+                os=-sysv
+                ;;
+        apollo68bsd)
+                basic_machine=m68k-apollo
+                os=-bsd
+                ;;
+        aros)
+                basic_machine=i386-pc
+                os=-aros
+                ;;
+        asmjs)
+                basic_machine=asmjs-unknown
+                ;;
+        aux)
+                basic_machine=m68k-apple
+                os=-aux
+                ;;
+        balance)
+                basic_machine=ns32k-sequent
+                os=-dynix
+                ;;
+        blackfin)
+                basic_machine=bfin-unknown
+                os=-linux
+                ;;
+        blackfin-*)
+                basic_machine=bfin-`echo $basic_machine | sed 's/^[^-]*-//'`
+                os=-linux
+                ;;
+        bluegene*)
+                basic_machine=powerpc-ibm
+                os=-cnk
+                ;;
+        c54x-*)
+                basic_machine=tic54x-`echo $basic_machine | sed 's/^[^-]*-//'`
+                ;;
+        c55x-*)
+                basic_machine=tic55x-`echo $basic_machine | sed 's/^[^-]*-//'`
+                ;;
+        c6x-*)
+                basic_machine=tic6x-`echo $basic_machine | sed 's/^[^-]*-//'`
+                ;;
+        c90)
+                basic_machine=c90-cray
+                os=-unicos
+                ;;
+        cegcc)
+                basic_machine=arm-unknown
+                os=-cegcc
+                ;;
+        convex-c1)
+                basic_machine=c1-convex
+                os=-bsd
+                ;;
+        convex-c2)
+                basic_machine=c2-convex
+                os=-bsd
+                ;;
+        convex-c32)
+                basic_machine=c32-convex
+                os=-bsd
+                ;;
+        convex-c34)
+                basic_machine=c34-convex
+                os=-bsd
+                ;;
+        convex-c38)
+                basic_machine=c38-convex
+                os=-bsd
+                ;;
+        cray | j90)
+                basic_machine=j90-cray
+                os=-unicos
+                ;;
+        craynv)
+                basic_machine=craynv-cray
+                os=-unicosmp
+                ;;
+        cr16 | cr16-*)
+                basic_machine=cr16-unknown
+                os=-elf
+                ;;
+        crds | unos)
+                basic_machine=m68k-crds
+                ;;
+        crisv32 | crisv32-* | etraxfs*)
+                basic_machine=crisv32-axis
+                ;;
+        cris | cris-* | etrax*)
+                basic_machine=cris-axis
+                ;;
+        crx)
+                basic_machine=crx-unknown
+                os=-elf
+                ;;
+        da30 | da30-*)
+                basic_machine=m68k-da30
+                ;;
+        decstation | decstation-3100 | pmax | pmax-* | pmin | dec3100 | decstatn)
+                basic_machine=mips-dec
+                ;;
+        decsystem10* | dec10*)
+                basic_machine=pdp10-dec
+                os=-tops10
+                ;;
+        decsystem20* | dec20*)
+                basic_machine=pdp10-dec
+                os=-tops20
+                ;;
+        delta | 3300 | motorola-3300 | motorola-delta \
+              | 3300-motorola | delta-motorola)
+                basic_machine=m68k-motorola
+                ;;
+        delta88)
+                basic_machine=m88k-motorola
+                os=-sysv3
+                ;;
+        dicos)
+                basic_machine=i686-pc
+                os=-dicos
+                ;;
+        djgpp)
+                basic_machine=i586-pc
+                os=-msdosdjgpp
+                ;;
+        dpx20 | dpx20-*)
+                basic_machine=rs6000-bull
+                os=-bosx
+                ;;
+        dpx2* | dpx2*-bull)
+                basic_machine=m68k-bull
+                os=-sysv3
+                ;;
+        ebmon29k)
+                basic_machine=a29k-amd
+                os=-ebmon
+                ;;
+        elxsi)
+                basic_machine=elxsi-elxsi
+                os=-bsd
+                ;;
+        encore | umax | mmax)
+                basic_machine=ns32k-encore
+                ;;
+        es1800 | OSE68k | ose68k | ose | OSE)
+                basic_machine=m68k-ericsson
+                os=-ose
+                ;;
+        fx2800)
+                basic_machine=i860-alliant
+                ;;
+        genix)
+                basic_machine=ns32k-ns
+                ;;
+        gmicro)
+                basic_machine=tron-gmicro
+                os=-sysv
+                ;;
+        go32)
+                basic_machine=i386-pc
+                os=-go32
+                ;;
+        h3050r* | hiux*)
+                basic_machine=hppa1.1-hitachi
+                os=-hiuxwe2
+                ;;
+        h8300hms)
+                basic_machine=h8300-hitachi
+                os=-hms
+                ;;
+        h8300xray)
+                basic_machine=h8300-hitachi
+                os=-xray
+                ;;
+        h8500hms)
+                basic_machine=h8500-hitachi
+                os=-hms
+                ;;
+        harris)
+                basic_machine=m88k-harris
+                os=-sysv3
+                ;;
+        hp300-*)
+                basic_machine=m68k-hp
+                ;;
+        hp300bsd)
+                basic_machine=m68k-hp
+                os=-bsd
+                ;;
+        hp300hpux)
+                basic_machine=m68k-hp
+                os=-hpux
+                ;;
+        hp3k9[0-9][0-9] | hp9[0-9][0-9])
+                basic_machine=hppa1.0-hp
+                ;;
+        hp9k2[0-9][0-9] | hp9k31[0-9])
+                basic_machine=m68000-hp
+                ;;
+        hp9k3[2-9][0-9])
+                basic_machine=m68k-hp
+                ;;
+        hp9k6[0-9][0-9] | hp6[0-9][0-9])
+                basic_machine=hppa1.0-hp
+                ;;
+        hp9k7[0-79][0-9] | hp7[0-79][0-9])
+                basic_machine=hppa1.1-hp
+                ;;
+        hp9k78[0-9] | hp78[0-9])
+                # FIXME: really hppa2.0-hp
+                basic_machine=hppa1.1-hp
+                ;;
+        hp9k8[67]1 | hp8[67]1 | hp9k80[24] | hp80[24] | hp9k8[78]9 | hp8[78]9 | hp9k893 | hp893)
+                # FIXME: really hppa2.0-hp
+                basic_machine=hppa1.1-hp
+                ;;
+        hp9k8[0-9][13679] | hp8[0-9][13679])
+                basic_machine=hppa1.1-hp
+                ;;
+        hp9k8[0-9][0-9] | hp8[0-9][0-9])
+                basic_machine=hppa1.0-hp
+                ;;
+        hppa-next)
+                os=-nextstep3
+                ;;
+        hppaosf)
+                basic_machine=hppa1.1-hp
+                os=-osf
+                ;;
+        hppro)
+                basic_machine=hppa1.1-hp
+                os=-proelf
+                ;;
+        i370-ibm* | ibm*)
+                basic_machine=i370-ibm
+                ;;
+        i*86v32)
+                basic_machine=`echo $1 | sed -e 's/86.*/86-pc/'`
+                os=-sysv32
+                ;;
+        i*86v4*)
+                basic_machine=`echo $1 | sed -e 's/86.*/86-pc/'`
+                os=-sysv4
+                ;;
+        i*86v)
+                basic_machine=`echo $1 | sed -e 's/86.*/86-pc/'`
+                os=-sysv
+                ;;
+        i*86sol2)
+                basic_machine=`echo $1 | sed -e 's/86.*/86-pc/'`
+                os=-solaris2
+                ;;
+        i386mach)
+                basic_machine=i386-mach
+                os=-mach
+                ;;
+        i386-vsta | vsta)
+                basic_machine=i386-unknown
+                os=-vsta
+                ;;
+        iris | iris4d)
+                basic_machine=mips-sgi
+                case $os in
+                    -irix*)
+                        ;;
+                    *)
+                        os=-irix4
+                        ;;
+                esac
+                ;;
+        isi68 | isi)
+                basic_machine=m68k-isi
+                os=-sysv
+                ;;
+        leon-*|leon[3-9]-*)
+                basic_machine=sparc-`echo $basic_machine | sed 's/-.*//'`
+                ;;
+        m68knommu)
+                basic_machine=m68k-unknown
+                os=-linux
+                ;;
+        m68knommu-*)
+                basic_machine=m68k-`echo $basic_machine | sed 's/^[^-]*-//'`
+                os=-linux
+                ;;
+        m88k-omron*)
+                basic_machine=m88k-omron
+                ;;
+        magnum | m3230)
+                basic_machine=mips-mips
+                os=-sysv
+                ;;
+        merlin)
+                basic_machine=ns32k-utek
+                os=-sysv
+                ;;
+        microblaze*)
+                basic_machine=microblaze-xilinx
+                ;;
+        mingw64)
+                basic_machine=x86_64-pc
+                os=-mingw64
+                ;;
+        mingw32)
+                basic_machine=i686-pc
+                os=-mingw32
+                ;;
+        mingw32ce)
+                basic_machine=arm-unknown
+                os=-mingw32ce
+                ;;
+        miniframe)
+                basic_machine=m68000-convergent
+                ;;
+        *mint | -mint[0-9]* | *MiNT | *MiNT[0-9]*)
+                basic_machine=m68k-atari
+                os=-mint
+                ;;
+        mips3*-*)
+                basic_machine=`echo $basic_machine | sed -e 's/mips3/mips64/'`
+                ;;
+        mips3*)
+                basic_machine=`echo $basic_machine | sed -e 's/mips3/mips64/'`-unknown
+                ;;
+        monitor)
+                basic_machine=m68k-rom68k
+                os=-coff
+                ;;
+        morphos)
+                basic_machine=powerpc-unknown
+                os=-morphos
+                ;;
+        moxiebox)
+                basic_machine=moxie-unknown
+                os=-moxiebox
+                ;;
+        msdos)
+                basic_machine=i386-pc
+                os=-msdos
+                ;;
+        ms1-*)
+                basic_machine=`echo $basic_machine | sed -e 's/ms1-/mt-/'`
+                ;;
+        msys)
+                basic_machine=i686-pc
+                os=-msys
+                ;;
+        mvs)
+                basic_machine=i370-ibm
+                os=-mvs
+                ;;
+        nacl)
+                basic_machine=le32-unknown
+                os=-nacl
+                ;;
+        ncr3000)
+                basic_machine=i486-ncr
+                os=-sysv4
+                ;;
+        netbsd386)
+                basic_machine=i386-unknown
+                os=-netbsd
+                ;;
+        netwinder)
+                basic_machine=armv4l-rebel
+                os=-linux
+                ;;
+        news | news700 | news800 | news900)
+                basic_machine=m68k-sony
+                os=-newsos
+                ;;
+        news1000)
+                basic_machine=m68030-sony
+                os=-newsos
+                ;;
+        news-3600 | risc-news)
+                basic_machine=mips-sony
+                os=-newsos
+                ;;
+        necv70)
+                basic_machine=v70-nec
+                os=-sysv
+                ;;
+        next | m*-next )
+                basic_machine=m68k-next
+                case $os in
+                    -nextstep* )
+                        ;;
+                    -ns2*)
+                      os=-nextstep2
+                        ;;
+                    *)
+                      os=-nextstep3
+                        ;;
+                esac
+                ;;
+        nh3000)
+                basic_machine=m68k-harris
+                os=-cxux
+                ;;
+        nh[45]000)
+                basic_machine=m88k-harris
+                os=-cxux
+                ;;
+        nindy960)
+                basic_machine=i960-intel
+                os=-nindy
+                ;;
+        mon960)
+                basic_machine=i960-intel
+                os=-mon960
+                ;;
+        nonstopux)
+                basic_machine=mips-compaq
+                os=-nonstopux
+                ;;
+        np1)
+                basic_machine=np1-gould
+                ;;
+        neo-tandem)
+                basic_machine=neo-tandem
+                ;;
+        nse-tandem)
+                basic_machine=nse-tandem
+                ;;
+        nsr-tandem)
+                basic_machine=nsr-tandem
+                ;;
+        op50n-* | op60c-*)
+                basic_machine=hppa1.1-oki
+                os=-proelf
+                ;;
+        openrisc | openrisc-*)
+                basic_machine=or32-unknown
+                ;;
+        os400)
+                basic_machine=powerpc-ibm
+                os=-os400
+                ;;
+        OSE68000 | ose68000)
+                basic_machine=m68000-ericsson
+                os=-ose
+                ;;
+        os68k)
+                basic_machine=m68k-none
+                os=-os68k
+                ;;
+        pa-hitachi)
+                basic_machine=hppa1.1-hitachi
+                os=-hiuxwe2
+                ;;
+        paragon)
+                basic_machine=i860-intel
+                os=-osf
+                ;;
+        parisc)
+                basic_machine=hppa-unknown
+                os=-linux
+                ;;
+        parisc-*)
+                basic_machine=hppa-`echo $basic_machine | sed 's/^[^-]*-//'`
+                os=-linux
+                ;;
+        pbd)
+                basic_machine=sparc-tti
+                ;;
+        pbb)
+                basic_machine=m68k-tti
+                ;;
+        pc532 | pc532-*)
+                basic_machine=ns32k-pc532
+                ;;
+        pc98)
+                basic_machine=i386-pc
+                ;;
+        pc98-*)
+                basic_machine=i386-`echo $basic_machine | sed 's/^[^-]*-//'`
+                ;;
+        pentium | p5 | k5 | k6 | nexgen | viac3)
+                basic_machine=i586-pc
+                ;;
+        pentiumpro | p6 | 6x86 | athlon | athlon_*)
+                basic_machine=i686-pc
+                ;;
+        pentiumii | pentium2 | pentiumiii | pentium3)
+                basic_machine=i686-pc
+                ;;
+        pentium4)
+                basic_machine=i786-pc
+                ;;
+        pentium-* | p5-* | k5-* | k6-* | nexgen-* | viac3-*)
+                basic_machine=i586-`echo $basic_machine | sed 's/^[^-]*-//'`
+                ;;
+        pentiumpro-* | p6-* | 6x86-* | athlon-*)
+                basic_machine=i686-`echo $basic_machine | sed 's/^[^-]*-//'`
+                ;;
+        pentiumii-* | pentium2-* | pentiumiii-* | pentium3-*)
+                basic_machine=i686-`echo $basic_machine | sed 's/^[^-]*-//'`
+                ;;
+        pentium4-*)
+                basic_machine=i786-`echo $basic_machine | sed 's/^[^-]*-//'`
+                ;;
+        pn)
+                basic_machine=pn-gould
+                ;;
+        power)  basic_machine=power-ibm
+                ;;
+        ppc | ppcbe)    basic_machine=powerpc-unknown
+                ;;
+        ppc-* | ppcbe-*)
+                basic_machine=powerpc-`echo $basic_machine | sed 's/^[^-]*-//'`
+                ;;
+        ppcle | powerpclittle | ppc-le | powerpc-little)
+                basic_machine=powerpcle-unknown
+                ;;
+        ppcle-* | powerpclittle-*)
+                basic_machine=powerpcle-`echo $basic_machine | sed 's/^[^-]*-//'`
+                ;;
+        ppc64)  basic_machine=powerpc64-unknown
+                ;;
+        ppc64-*) basic_machine=powerpc64-`echo $basic_machine | sed 's/^[^-]*-//'`
+                ;;
+        ppc64le | powerpc64little | ppc64-le | powerpc64-little)
+                basic_machine=powerpc64le-unknown
+                ;;
+        ppc64le-* | powerpc64little-*)
+                basic_machine=powerpc64le-`echo $basic_machine | sed 's/^[^-]*-//'`
+                ;;
+        ps2)
+                basic_machine=i386-ibm
+                ;;
+        pw32)
+                basic_machine=i586-unknown
+                os=-pw32
+                ;;
+        rdos | rdos64)
+                basic_machine=x86_64-pc
+                os=-rdos
+                ;;
+        rdos32)
+                basic_machine=i386-pc
+                os=-rdos
+                ;;
+        rom68k)
+                basic_machine=m68k-rom68k
+                os=-coff
+                ;;
+        rm[46]00)
+                basic_machine=mips-siemens
+                ;;
+        rtpc | rtpc-*)
+                basic_machine=romp-ibm
+                ;;
+        s390 | s390-*)
+                basic_machine=s390-ibm
+                ;;
+        s390x | s390x-*)
+                basic_machine=s390x-ibm
+                ;;
+        sa29200)
+                basic_machine=a29k-amd
+                os=-udi
+                ;;
+        sb1)
+                basic_machine=mipsisa64sb1-unknown
+                ;;
+        sb1el)
+                basic_machine=mipsisa64sb1el-unknown
+                ;;
+        sde)
+                basic_machine=mipsisa32-sde
+                os=-elf
+                ;;
+        sei)
+                basic_machine=mips-sei
+                os=-seiux
+                ;;
+        sequent)
+                basic_machine=i386-sequent
+                ;;
+        sh)
+                basic_machine=sh-hitachi
+                os=-hms
+                ;;
+        sh5el)
+                basic_machine=sh5le-unknown
+                ;;
+        sh64)
+                basic_machine=sh64-unknown
+                ;;
+        sparclite-wrs | simso-wrs)
+                basic_machine=sparclite-wrs
+                os=-vxworks
+                ;;
+        sps7)
+                basic_machine=m68k-bull
+                os=-sysv2
+                ;;
+        spur)
+                basic_machine=spur-unknown
+                ;;
+        st2000)
+                basic_machine=m68k-tandem
+                ;;
+        stratus)
+                basic_machine=i860-stratus
+                os=-sysv4
+                ;;
+        strongarm-* | thumb-*)
+                basic_machine=arm-`echo $basic_machine | sed 's/^[^-]*-//'`
+                ;;
+        sun2)
+                basic_machine=m68000-sun
+                ;;
+        sun2os3)
+                basic_machine=m68000-sun
+                os=-sunos3
+                ;;
+        sun2os4)
+                basic_machine=m68000-sun
+                os=-sunos4
+                ;;
+        sun3os3)
+                basic_machine=m68k-sun
+                os=-sunos3
+                ;;
+        sun3os4)
+                basic_machine=m68k-sun
+                os=-sunos4
+                ;;
+        sun4os3)
+                basic_machine=sparc-sun
+                os=-sunos3
+                ;;
+        sun4os4)
+                basic_machine=sparc-sun
+                os=-sunos4
+                ;;
+        sun4sol2)
+                basic_machine=sparc-sun
+                os=-solaris2
+                ;;
+        sun3 | sun3-*)
+                basic_machine=m68k-sun
+                ;;
+        sun4)
+                basic_machine=sparc-sun
+                ;;
+        sun386 | sun386i | roadrunner)
+                basic_machine=i386-sun
+                ;;
+        sv1)
+                basic_machine=sv1-cray
+                os=-unicos
+                ;;
+        symmetry)
+                basic_machine=i386-sequent
+                os=-dynix
+                ;;
+        t3e)
+                basic_machine=alphaev5-cray
+                os=-unicos
+                ;;
+        t90)
+                basic_machine=t90-cray
+                os=-unicos
+                ;;
+        tile*)
+                basic_machine=$basic_machine-unknown
+                os=-linux-gnu
+                ;;
+        tx39)
+                basic_machine=mipstx39-unknown
+                ;;
+        tx39el)
+                basic_machine=mipstx39el-unknown
+                ;;
+        toad1)
+                basic_machine=pdp10-xkl
+                os=-tops20
+                ;;
+        tower | tower-32)
+                basic_machine=m68k-ncr
+                ;;
+        tpf)
+                basic_machine=s390x-ibm
+                os=-tpf
+                ;;
+        udi29k)
+                basic_machine=a29k-amd
+                os=-udi
+                ;;
+        ultra3)
+                basic_machine=a29k-nyu
+                os=-sym1
+                ;;
+        v810 | necv810)
+                basic_machine=v810-nec
+                os=-none
+                ;;
+        vaxv)
+                basic_machine=vax-dec
+                os=-sysv
+                ;;
+        vms)
+                basic_machine=vax-dec
+                os=-vms
+                ;;
+        vpp*|vx|vx-*)
+                basic_machine=f301-fujitsu
+                ;;
+        vxworks960)
+                basic_machine=i960-wrs
+                os=-vxworks
+                ;;
+        vxworks68)
+                basic_machine=m68k-wrs
+                os=-vxworks
+                ;;
+        vxworks29k)
+                basic_machine=a29k-wrs
+                os=-vxworks
+                ;;
+        w65*)
+                basic_machine=w65-wdc
+                os=-none
+                ;;
+        w89k-*)
+                basic_machine=hppa1.1-winbond
+                os=-proelf
+                ;;
+        xbox)
+                basic_machine=i686-pc
+                os=-mingw32
+                ;;
+        xps | xps100)
+                basic_machine=xps100-honeywell
+                ;;
+        xscale-* | xscalee[bl]-*)
+                basic_machine=`echo $basic_machine | sed 's/^xscale/arm/'`
+                ;;
+        ymp)
+                basic_machine=ymp-cray
+                os=-unicos
+                ;;
+        z8k-*-coff)
+                basic_machine=z8k-unknown
+                os=-sim
+                ;;
+        z80-*-coff)
+                basic_machine=z80-unknown
+                os=-sim
+                ;;
+        none)
+                basic_machine=none-none
+                os=-none
+                ;;
+# Here we handle the default manufacturer of certain CPU types.  It is in
+# some cases the only manufacturer, in others, it is the most popular.
+        w89k)
+                basic_machine=hppa1.1-winbond
+                ;;
+        op50n)
+                basic_machine=hppa1.1-oki
+                ;;
+        op60c)
+                basic_machine=hppa1.1-oki
+                ;;
+        romp)
+                basic_machine=romp-ibm
+                ;;
+        mmix)
+                basic_machine=mmix-knuth
+                ;;
+        rs6000)
+                basic_machine=rs6000-ibm
+                ;;
+        vax)
+                basic_machine=vax-dec
+                ;;
+        pdp10)
+                # there are many clones, so DEC is not a safe bet
+                basic_machine=pdp10-unknown
+                ;;
+        pdp11)
+                basic_machine=pdp11-dec
+                ;;
+        we32k)
+                basic_machine=we32k-att
+                ;;
+        sh[1234] | sh[24]a | sh[24]aeb | sh[34]eb | sh[1234]le | sh[23]ele)
+                basic_machine=sh-unknown
+                ;;
+        sparc | sparcv8 | sparcv9 | sparcv9b | sparcv9v)
+                basic_machine=sparc-sun
+                ;;
+        cydra)
+                basic_machine=cydra-cydrome
+                ;;
+        orion)
+                basic_machine=orion-highlevel
+                ;;
+        orion105)
+                basic_machine=clipper-highlevel
+                ;;
+        mac | mpw | mac-mpw)
+                basic_machine=m68k-apple
+                ;;
+        pmac | pmac-mpw)
+                basic_machine=powerpc-apple
+                ;;
+        *-unknown)
+                # Make sure to match an already-canonicalized machine name.
+                ;;
+        *)
+                echo Invalid configuration \`$1\': machine \`$basic_machine\' not recognized 1>&2
+                exit 1
+                ;;
+esac
+# Here we canonicalize certain aliases for manufacturers.
+case $basic_machine in
+        *-digital*)
+                basic_machine=`echo $basic_machine | sed 's/digital.*/dec/'`
+                ;;
+        *-commodore*)
+                basic_machine=`echo $basic_machine | sed 's/commodore.*/cbm/'`
+                ;;
+        *)
+                ;;
+esac
+# Decode manufacturer-specific aliases for certain operating systems.
+if [ x"$os" != x"" ]
+then
+case $os in
+        # First match some system type aliases
+        # that might get confused with valid system types.
+        # -solaris* is a basic system type, with this one exception.
+        -auroraux)
+                os=-auroraux
+                ;;
+        -solaris1 | -solaris1.*)
+                os=`echo $os | sed -e 's|solaris1|sunos4|'`
+                ;;
+        -solaris)
+                os=-solaris2
+                ;;
+        -svr4*)
+                os=-sysv4
+                ;;
+        -unixware*)
+                os=-sysv4.2uw
+                ;;
+        -gnu/linux*)
+                os=`echo $os | sed -e 's|gnu/linux|linux-gnu|'`
+                ;;
+        # First accept the basic system types.
+        # The portable systems comes first.
+        # Each alternative MUST END IN A *, to match a version number.
+        # -sysv* is not here because it comes later, after sysvr4.
+        -gnu* | -bsd* | -mach* | -minix* | -genix* | -ultrix* | -irix* \
+              | -*vms* | -sco* | -esix* | -isc* | -aix* | -cnk* | -sunos | -sunos[34]*\
+              | -hpux* | -unos* | -osf* | -luna* | -dgux* | -auroraux* | -solaris* \
+              | -sym* | -kopensolaris* | -plan9* \
+              | -amigaos* | -amigados* | -msdos* | -newsos* | -unicos* | -aof* \
+              | -aos* | -aros* | -cloudabi* | -sortix* \
+              | -nindy* | -vxsim* | -vxworks* | -ebmon* | -hms* | -mvs* \
+              | -clix* | -riscos* | -uniplus* | -iris* | -rtu* | -xenix* \
+              | -hiux* | -386bsd* | -knetbsd* | -mirbsd* | -netbsd* \
+              | -bitrig* | -openbsd* | -solidbsd* \
+              | -ekkobsd* | -kfreebsd* | -freebsd* | -riscix* | -lynxos* \
+              | -bosx* | -nextstep* | -cxux* | -aout* | -elf* | -oabi* \
+              | -ptx* | -coff* | -ecoff* | -winnt* | -domain* | -vsta* \
+              | -udi* | -eabi* | -lites* | -ieee* | -go32* | -aux* \
+              | -chorusos* | -chorusrdb* | -cegcc* \
+              | -cygwin* | -msys* | -pe* | -psos* | -moss* | -proelf* | -rtems* \
+              | -mingw32* | -mingw64* | -linux-gnu* | -linux-android* \
+              | -linux-newlib* | -linux-musl* | -linux-uclibc* \
+              | -uxpv* | -beos* | -mpeix* | -udk* | -moxiebox* \
+              | -interix* | -uwin* | -mks* | -rhapsody* | -darwin* | -opened* \
+              | -openstep* | -oskit* | -conix* | -pw32* | -nonstopux* \
+              | -storm-chaos* | -tops10* | -tenex* | -tops20* | -its* \
+              | -os2* | -vos* | -palmos* | -uclinux* | -nucleus* \
+              | -morphos* | -superux* | -rtmk* | -rtmk-nova* | -windiss* \
+              | -powermax* | -dnix* | -nx6 | -nx7 | -sei* | -dragonfly* \
+              | -skyos* | -haiku* | -rdos* | -toppers* | -drops* | -es* | -tirtos*)
+        # Remember, each alternative MUST END IN *, to match a version number.
+                ;;
+        -qnx*)
+                case $basic_machine in
+                    x86-* | i*86-*)
+                        ;;
+                    *)
+                        os=-nto$os
+                        ;;
+                esac
+                ;;
+        -nto-qnx*)
+                ;;
+        -nto*)
+                os=`echo $os | sed -e 's|nto|nto-qnx|'`
+                ;;
+        -sim | -es1800* | -hms* | -xray | -os68k* | -none* | -v88r* \
+              | -windows* | -osx | -abug | -netware* | -os9* | -beos* | -haiku* \
+              | -macos* | -mpw* | -magic* | -mmixware* | -mon960* | -lnews*)
+                ;;
+        -mac*)
+                os=`echo $os | sed -e 's|mac|macos|'`
+                ;;
+        -linux-dietlibc)
+                os=-linux-dietlibc
+                ;;
+        -linux*)
+                os=`echo $os | sed -e 's|linux|linux-gnu|'`
+                ;;
+        -sunos5*)
+                os=`echo $os | sed -e 's|sunos5|solaris2|'`
+                ;;
+        -sunos6*)
+                os=`echo $os | sed -e 's|sunos6|solaris3|'`
+                ;;
+        -opened*)
+                os=-openedition
+                ;;
+        -os400*)
+                os=-os400
+                ;;
+        -wince*)
+                os=-wince
+                ;;
+        -osfrose*)
+                os=-osfrose
+                ;;
+        -osf*)
+                os=-osf
+                ;;
+        -utek*)
+                os=-bsd
+                ;;
+        -dynix*)
+                os=-bsd
+                ;;
+        -acis*)
+                os=-aos
+                ;;
+        -atheos*)
+                os=-atheos
+                ;;
+        -syllable*)
+                os=-syllable
+                ;;
+        -386bsd)
+                os=-bsd
+                ;;
+        -ctix* | -uts*)
+                os=-sysv
+                ;;
+        -nova*)
+                os=-rtmk-nova
+                ;;
+        -ns2 )
+                os=-nextstep2
+                ;;
+        -nsk*)
+                os=-nsk
+                ;;
+        # Preserve the version number of sinix5.
+        -sinix5.*)
+                os=`echo $os | sed -e 's|sinix|sysv|'`
+                ;;
+        -sinix*)
+                os=-sysv4
+                ;;
+        -tpf*)
+                os=-tpf
+                ;;
+        -triton*)
+                os=-sysv3
+                ;;
+        -oss*)
+                os=-sysv3
+                ;;
+        -svr4)
+                os=-sysv4
+                ;;
+        -svr3)
+                os=-sysv3
+                ;;
+        -sysvr4)
+                os=-sysv4
+                ;;
+        # This must come after -sysvr4.
+        -sysv*)
+                ;;
+        -ose*)
+                os=-ose
+                ;;
+        -es1800*)
+                os=-ose
+                ;;
+        -xenix)
+                os=-xenix
+                ;;
+        -*mint | -mint[0-9]* | -*MiNT | -MiNT[0-9]*)
+                os=-mint
+                ;;
+        -aros*)
+                os=-aros
+                ;;
+        -zvmoe)
+                os=-zvmoe
+                ;;
+        -dicos*)
+                os=-dicos
+                ;;
+        -nacl*)
+                ;;
+        -none)
+                ;;
+        *)
+                # Get rid of the `-' at the beginning of $os.
+                os=`echo $os | sed 's/[^-]*-//'`
+                echo Invalid configuration \`$1\': system \`$os\' not recognized 1>&2
+                exit 1
+                ;;
+esac
+else
+# Here we handle the default operating systems that come with various machines.
+# The value should be what the vendor currently ships out the door with their
+# machine or put another way, the most popular os provided with the machine.
+# Note that if you're going to try to match "-MANUFACTURER" here (say,
+# "-sun"), then you have to tell the case statement up towards the top
+# that MANUFACTURER isn't an operating system.  Otherwise, code above
+# will signal an error saying that MANUFACTURER isn't an operating
+# system, and we'll never get to this point.
+case $basic_machine in
+        score-*)
+                os=-elf
+                ;;
+        spu-*)
+                os=-elf
+                ;;
+        *-acorn)
+                os=-riscix1.2
+                ;;
+        arm*-rebel)
+                os=-linux
+                ;;
+        arm*-semi)
+                os=-aout
+                ;;
+        c4x-* | tic4x-*)
+                os=-coff
+                ;;
+        c8051-*)
+                os=-elf
+                ;;
+        hexagon-*)
+                os=-elf
+                ;;
+        tic54x-*)
+                os=-coff
+                ;;
+        tic55x-*)
+                os=-coff
+                ;;
+        tic6x-*)
+                os=-coff
+                ;;
+        # This must come before the *-dec entry.
+        pdp10-*)
+                os=-tops20
+                ;;
+        pdp11-*)
+                os=-none
+                ;;
+        *-dec | vax-*)
+                os=-ultrix4.2
+                ;;
+        m68*-apollo)
+                os=-domain
+                ;;
+        i386-sun)
+                os=-sunos4.0.2
+                ;;
+        m68000-sun)
+                os=-sunos3
+                ;;
+        m68*-cisco)
+                os=-aout
+                ;;
+        mep-*)
+                os=-elf
+                ;;
+        mips*-cisco)
+                os=-elf
+                ;;
+        mips*-*)
+                os=-elf
+                ;;
+        or32-*)
+                os=-coff
+                ;;
+        *-tti)  # must be before sparc entry or we get the wrong os.
+                os=-sysv3
+                ;;
+        sparc-* | *-sun)
+                os=-sunos4.1.1
+                ;;
+        *-be)
+                os=-beos
+                ;;
+        *-haiku)
+                os=-haiku
+                ;;
+        *-ibm)
+                os=-aix
+                ;;
+        *-knuth)
+                os=-mmixware
+                ;;
+        *-wec)
+                os=-proelf
+                ;;
+        *-winbond)
+                os=-proelf
+                ;;
+        *-oki)
+                os=-proelf
+                ;;
+        *-hp)
+                os=-hpux
+                ;;
+        *-hitachi)
+                os=-hiux
+                ;;
+        i860-* | *-att | *-ncr | *-altos | *-motorola | *-convergent)
+                os=-sysv
+                ;;
+        *-cbm)
+                os=-amigaos
+                ;;
+        *-dg)
+                os=-dgux
+                ;;
+        *-dolphin)
+                os=-sysv3
+                ;;
+        m68k-ccur)
+                os=-rtu
+                ;;
+        m88k-omron*)
+                os=-luna
+                ;;
+        *-next )
+                os=-nextstep
+                ;;
+        *-sequent)
+                os=-ptx
+                ;;
+        *-crds)
+                os=-unos
+                ;;
+        *-ns)
+                os=-genix
+                ;;
+        i370-*)
+                os=-mvs
+                ;;
+        *-next)
+                os=-nextstep3
+                ;;
+        *-gould)
+                os=-sysv
+                ;;
+        *-highlevel)
+                os=-bsd
+                ;;
+        *-encore)
+                os=-bsd
+                ;;
+        *-sgi)
+                os=-irix
+                ;;
+        *-siemens)
+                os=-sysv4
+                ;;
+        *-masscomp)
+                os=-rtu
+                ;;
+        f30[01]-fujitsu | f700-fujitsu)
+                os=-uxpv
+                ;;
+        *-rom68k)
+                os=-coff
+                ;;
+        *-*bug)
+                os=-coff
+                ;;
+        *-apple)
+                os=-macos
+                ;;
+        *-atari*)
+                os=-mint
+                ;;
+        *)
+                os=-none
+                ;;
+esac
+fi
+# Here we handle the case where we know the os, and the CPU type, but not the
+# manufacturer.  We pick the logical manufacturer.
+vendor=unknown
+case $basic_machine in
+        *-unknown)
+                case $os in
+                        -riscix*)
+                                vendor=acorn
+                                ;;
+                        -sunos*)
+                                vendor=sun
+                                ;;
+                        -cnk*|-aix*)
+                                vendor=ibm
+                                ;;
+                        -beos*)
+                                vendor=be
+                                ;;
+                        -hpux*)
+                                vendor=hp
+                                ;;
+                        -mpeix*)
+                                vendor=hp
+                                ;;
+                        -hiux*)
+                                vendor=hitachi
+                                ;;
+                        -unos*)
+                                vendor=crds
+                                ;;
+                        -dgux*)
+                                vendor=dg
+                                ;;
+                        -luna*)
+                                vendor=omron
+                                ;;
+                        -genix*)
+                                vendor=ns
+                                ;;
+                        -mvs* | -opened*)
+                                vendor=ibm
+                                ;;
+                        -os400*)
+                                vendor=ibm
+                                ;;
+                        -ptx*)
+                                vendor=sequent
+                                ;;
+                        -tpf*)
+                                vendor=ibm
+                                ;;
+                        -vxsim* | -vxworks* | -windiss*)
+                                vendor=wrs
+                                ;;
+                        -aux*)
+                                vendor=apple
+                                ;;
+                        -hms*)
+                                vendor=hitachi
+                                ;;
+                        -mpw* | -macos*)
+                                vendor=apple
+                                ;;
+                        -*mint | -mint[0-9]* | -*MiNT | -MiNT[0-9]*)
+                                vendor=atari
+                                ;;
+                        -vos*)
+                                vendor=stratus
+                                ;;
+                esac
+                basic_machine=`echo $basic_machine | sed "s/unknown/$vendor/"`
+                ;;
+esac
+echo $basic_machine$os
+exit
+# Local variables:
+# eval: (add-hook 'write-file-hooks 'time-stamp)
+# time-stamp-start: "timestamp='"
+# time-stamp-format: "%:y-%02m-%02d"
+# time-stamp-end: "'"
+# End:
+/usr/share/automake-1.15/config.sub

automake/depcomp

-              r0720e049
+              r3d4b23fa
 # depcomp - compile a program generating dependencies as side-effects
+scriptversion=2013-05-30.07; # UTC
+# Copyright (C) 1999-2014 Free Software Foundation, Inc.
+scriptversion=2011-12-04.11; # UTC
+# Copyright (C) 1999, 2000, 2003, 2004, 2005, 2006, 2007, 2009, 2010,
+# 2011 Free Software Foundation, Inc.
 # This program is free software; you can redistribute it and/or modify
 …
 case $1 in
   '')
     echo "$0: No command.  Try '$0 --help' for more information." 1>&2
     exit 1;
     ;;
+     echo "$0: No command.  Try \`$0 --help' for more information." 1>&2
+     exit 1;
+     ;;
   -h | --h*)
     cat <<\EOF
 …
 Environment variables:
   depmode     Dependency tracking mode.
   source      Source file read by 'PROGRAMS ARGS'.
   object      Object file output by 'PROGRAMS ARGS'.
+  source      Source file read by `PROGRAMS ARGS'.
+  object      Object file output by `PROGRAMS ARGS'.
   DEPDIR      directory where to store dependencies.
   depfile     Dependency file to output.
 …
 esac
-# Get the directory component of the given path, and save it in the
-# global variables '$dir'.  Note that this directory component will
-# be either empty or ending with a '/' character.  This is deliberate.
-set_dir_from ()
+{
-  case $1 in
-    */*) dir=`echo "$1" | sed -e 's|/[^/]*$|/|'`;;
-      *) dir=;;
-  esac
+}
-# Get the suffix-stripped basename of the given path, and save it the
-# global variable '$base'.
-set_base_from ()
+{
-  base=`echo "$1" | sed -e 's|^.*/||' -e 's/\.[^.]*$//'`
+}
-# If no dependency file was actually created by the compiler invocation,
-# we still have to create a dummy depfile, to avoid errors with the
-# Makefile "include basename.Plo" scheme.
-make_dummy_depfile ()
+{
-  echo "#dummy" > "$depfile"
+}
-# Factor out some common post-processing of the generated depfile.
-# Requires the auxiliary global variable '$tmpdepfile' to be set.
-aix_post_process_depfile ()
+{
-  # If the compiler actually managed to produce a dependency file,
-  # post-process it.
-  if test -f "$tmpdepfile"; then
-    # Each line is of the form 'foo.o: dependency.h'.
-    # Do two passes, one to just change these to
-    #   $object: dependency.h
-    # and one to simply output
-    #   dependency.h:
-    # which is needed to avoid the deleted-header problem.
-    { sed -e "s,^.*\.[$lower]*:,$object:," < "$tmpdepfile"
-      sed -e "s,^.*\.[$lower]*:[$tab ]*,," -e 's,$,:,' < "$tmpdepfile"
-    } > "$depfile"
-    rm -f "$tmpdepfile"
-  else
-    make_dummy_depfile
-  fi
+}
-# A tabulation character.
-tab='   '
-# A newline character.
-nl='
+'
-# Character ranges might be problematic outside the C locale.
-# These definitions help.
-upper=ABCDEFGHIJKLMNOPQRSTUVWXYZ
-lower=abcdefghijklmnopqrstuvwxyz
-digits=0123456789
-alpha=${upper}${lower}
 if test -z "$depmode" || test -z "$source" || test -z "$object"; then
   echo "depcomp: Variables source, object and depmode must be set" 1>&2
 …
 rm -f "$tmpdepfile"
-# Avoid interferences from the environment.
-gccflag= dashmflag=
 # Some modes work just like other modes, but use different flags.  We
 …
 if test "$depmode" = dashXmstdout; then
   # This is just like dashmstdout with a different argument.
   dashmflag=-xM
   depmode=dashmstdout
+   # This is just like dashmstdout with a different argument.
+   dashmflag=-xM
+   depmode=dashmstdout
 fi
 cygpath_u="cygpath -u -f -"
 if test "$depmode" = msvcmsys; then
   # This is just like msvisualcpp but w/o cygpath translation.
   # Just convert the backslash-escaped backslashes to single forward
   # slashes to satisfy depend.m4
   cygpath_u='sed s,\\\\,/,g'
   depmode=msvisualcpp
+   # This is just like msvisualcpp but w/o cygpath translation.
+   # Just convert the backslash-escaped backslashes to single forward
+   # slashes to satisfy depend.m4
+   cygpath_u='sed s,\\\\,/,g'
+   depmode=msvisualcpp
 fi
 if test "$depmode" = msvc7msys; then
+  # This is just like msvc7 but w/o cygpath translation.
+  # Just convert the backslash-escaped backslashes to single forward
+  # slashes to satisfy depend.m4
+  cygpath_u='sed s,\\\\,/,g'
+  depmode=msvc7
+fi
+if test "$depmode" = xlc; then
+  # IBM C/C++ Compilers xlc/xlC can output gcc-like dependency information.
+  gccflag=-qmakedep=gcc,-MF
+  depmode=gcc
+   # This is just like msvc7 but w/o cygpath translation.
+   # Just convert the backslash-escaped backslashes to single forward
+   # slashes to satisfy depend.m4
+   cygpath_u='sed s,\\\\,/,g'
+   depmode=msvc7
 fi
 …
   "$@"
   stat=$?
+  if test $stat -ne 0; then
+  if test $stat -eq 0; then :
+  else
     rm -f "$tmpdepfile"
     exit $stat
 …
 gcc)
-## Note that this doesn't just cater to obsosete pre-3.x GCC compilers.
-## but also to in-use compilers like IMB xlc/xlC and the HP C compiler.
-## (see the conditional assignment to $gccflag above).
 ## There are various ways to get dependency output from gcc.  Here's
 ## why we pick this rather obscure method:
 …
 ##   (We might end up doing this anyway to support other compilers.)
 ## - The DEPENDENCIES_OUTPUT environment variable makes gcc act like
+##   -MM, not -M (despite what the docs say).  Also, it might not be
+##   supported by the other compilers which use the 'gcc' depmode.
+##   -MM, not -M (despite what the docs say).
 ## - Using -M directly means running the compiler twice (even worse
 ##   than renaming).
 …
   "$@" -Wp,"$gccflag$tmpdepfile"
   stat=$?
+  if test $stat -ne 0; then
+  if test $stat -eq 0; then :
+  else
     rm -f "$tmpdepfile"
     exit $stat
 …
   rm -f "$depfile"
   echo "$object : \\" > "$depfile"
   # The second -e expression handles DOS-style file names with drive
   # letters.
+  alpha=ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz
+## The second -e expression handles DOS-style file names with drive letters.
   sed -e 's/^[^:]*: / /' \
       -e 's/^['$alpha']:\/[^:]*: / /' < "$tmpdepfile" >> "$depfile"
 ## This next piece of magic avoids the "deleted header file" problem.
+## This next piece of magic avoids the `deleted header file' problem.
 ## The problem is that when a header file which appears in a .P file
 ## is deleted, the dependency causes make to die (because there is
 …
 ## dummy dependencies for each header file.  Too bad gcc doesn't do
 ## this for us directly.
+## Some versions of gcc put a space before the ':'.  On the theory
+  tr ' ' '
+' < "$tmpdepfile" |
+## Some versions of gcc put a space before the `:'.  On the theory
 ## that the space means something, we add a space to the output as
 ## well.  hp depmode also adds that space, but also prefixes the VPATH
 …
 ## Some versions of the HPUX 10.20 sed can't process this invocation
 ## correctly.  Breaking it into two sed invocations is a workaround.
+  tr ' ' "$nl" < "$tmpdepfile" \
+    | sed -e 's/^\\$//' -e '/^$/d' -e "s|.*$object$||" -e '/:$/d' \
+    | sed -e 's/$/ :/' >> "$depfile"
+    sed -e 's/^\\$//' -e '/^$/d' -e "s|.*$object$||" -e '/:$/d' \
+      | sed -e 's/$/ :/' >> "$depfile"
   rm -f "$tmpdepfile"
   ;;
 …
   fi
   stat=$?
+  if test $stat -ne 0; then
+  if test $stat -eq 0; then :
+  else
     rm -f "$tmpdepfile"
     exit $stat
 …
   if test -f "$tmpdepfile"; then  # yes, the sourcefile depend on other files
     echo "$object : \\" > "$depfile"
     # Clip off the initial element (the dependent).  Don't try to be
     # clever and replace this with sed code, as IRIX sed won't handle
     # lines with more than a fixed number of characters (4096 in
     # IRIX 6.2 sed, 8192 in IRIX 6.5).  We also remove comment lines;
     # the IRIX cc adds comments like '#:fec' to the end of the
+    # the IRIX cc adds comments like `#:fec' to the end of the
     # dependency line.
+    tr ' ' "$nl" < "$tmpdepfile" \
+      | sed -e 's/^.*\.o://' -e 's/#.*$//' -e '/^$/ d' \
+      | tr "$nl" ' ' >> "$depfile"
+    tr ' ' '
+' < "$tmpdepfile" \
+    | sed -e 's/^.*\.o://' -e 's/#.*$//' -e '/^$/ d' | \
+    tr '
+' ' ' >> "$depfile"
     echo >> "$depfile"
     # The second pass generates a dummy entry for each header file.
+    tr ' ' "$nl" < "$tmpdepfile" \
+      | sed -e 's/^.*\.o://' -e 's/#.*$//' -e '/^$/ d' -e 's/$/:/' \
+      >> "$depfile"
+  else
+    make_dummy_depfile
+  fi
+  rm -f "$tmpdepfile"
+  ;;
+xlc)
+  # This case exists only to let depend.m4 do its work.  It works by
+  # looking at the text of this script.  This case will never be run,
+  # since it is checked for above.
+  exit 1
+    tr ' ' '
+' < "$tmpdepfile" \
+   | sed -e 's/^.*\.o://' -e 's/#.*$//' -e '/^$/ d' -e 's/$/:/' \
+   >> "$depfile"
+  else
+    # The sourcefile does not contain any dependencies, so just
+    # store a dummy comment line, to avoid errors with the Makefile
+    # "include basename.Plo" scheme.
+    echo "#dummy" > "$depfile"
+  fi
+  rm -f "$tmpdepfile"
   ;;
 …
   # The C for AIX Compiler uses -M and outputs the dependencies
   # in a .u file.  In older versions, this file always lives in the
   # current directory.  Also, the AIX compiler puts '$object:' at the
+  # current directory.  Also, the AIX compiler puts `$object:' at the
   # start of each line; $object doesn't have directory information.
   # Version 6 uses the directory in both cases.
+  set_dir_from "$object"
+  set_base_from "$object"
+  dir=`echo "$object" | sed -e 's|/[^/]*$|/|'`
+  test "x$dir" = "x$object" && dir=
+  base=`echo "$object" | sed -e 's|^.*/||' -e 's/\.o$//' -e 's/\.lo$//'`
   if test "$libtool" = yes; then
     tmpdepfile1=$dir$base.u
 …
   fi
   stat=$?
+  if test $stat -ne 0; then
+  if test $stat -eq 0; then :
+  else
     rm -f "$tmpdepfile1" "$tmpdepfile2" "$tmpdepfile3"
     exit $stat
 …
     test -f "$tmpdepfile" && break
   done
+  aix_post_process_depfile
+  ;;
+tcc)
+  # tcc (Tiny C Compiler) understand '-MD -MF file' since version 0.9.26
+  # FIXME: That version still under development at the moment of writing.
+  #        Make that this statement remains true also for stable, released
+  #        versions.
+  # It will wrap lines (doesn't matter whether long or short) with a
+  # trailing '\', as in:
+  #
+  #   foo.o : \
+  #    foo.c \
+  #    foo.h \
+  #
+  # It will put a trailing '\' even on the last line, and will use leading
+  # spaces rather than leading tabs (at least since its commit 0394caf7
+  # "Emit spaces for -MD").
+  "$@" -MD -MF "$tmpdepfile"
+  stat=$?
+  if test $stat -ne 0; then
+    rm -f "$tmpdepfile"
+    exit $stat
+  fi
+  rm -f "$depfile"
+  # Each non-empty line is of the form 'foo.o : \' or ' dep.h \'.
+  # We have to change lines of the first kind to '$object: \'.
+  sed -e "s|.*:|$object :|" < "$tmpdepfile" > "$depfile"
+  # And for each line of the second kind, we have to emit a 'dep.h:'
+  # dummy dependency, to avoid the deleted-header problem.
+  sed -n -e 's|^  *\(.*\) *\\$|\1:|p' < "$tmpdepfile" >> "$depfile"
+  rm -f "$tmpdepfile"
+  ;;
+## The order of this option in the case statement is important, since the
+## shell code in configure will try each of these formats in the order
+## listed in this file.  A plain '-MD' option would be understood by many
+## compilers, so we must ensure this comes after the gcc and icc options.
+pgcc)
+  # Portland's C compiler understands '-MD'.
+  # Will always output deps to 'file.d' where file is the root name of the
+  # source file under compilation, even if file resides in a subdirectory.
+  # The object file name does not affect the name of the '.d' file.
+  # pgcc 10.2 will output
+  if test -f "$tmpdepfile"; then
+    # Each line is of the form `foo.o: dependent.h'.
+    # Do two passes, one to just change these to
+    # `$object: dependent.h' and one to simply `dependent.h:'.
+    sed -e "s,^.*\.[a-z]*:,$object:," < "$tmpdepfile" > "$depfile"
+    # That's a tab and a space in the [].
+    sed -e 's,^.*\.[a-z]*:[      ]*,,' -e 's,$,:,' < "$tmpdepfile" >> "$depfile"
+  else
+    # The sourcefile does not contain any dependencies, so just
+    # store a dummy comment line, to avoid errors with the Makefile
+    # "include basename.Plo" scheme.
+    echo "#dummy" > "$depfile"
+  fi
+  rm -f "$tmpdepfile"
+  ;;
+icc)
+  # Intel's C compiler understands `-MD -MF file'.  However on
+  #    icc -MD -MF foo.d -c -o sub/foo.o sub/foo.c
+  # ICC 7.0 will fill foo.d with something like
+  #    foo.o: sub/foo.c
+  #    foo.o: sub/foo.h
+  # which is wrong.  We want:
+  #    sub/foo.o: sub/foo.c
+  #    sub/foo.o: sub/foo.h
+  #    sub/foo.c:
+  #    sub/foo.h:
+  # ICC 7.1 will output
   #    foo.o: sub/foo.c sub/foo.h
   # and will wrap long lines using '\' :
+  # and will wrap long lines using \ :
   #    foo.o: sub/foo.c ... \
   #     sub/foo.h ... \
   #     ...
+  set_dir_from "$object"
+  # Use the source, not the object, to determine the base name, since
+  # that's sadly what pgcc will do too.
+  set_base_from "$source"
+  tmpdepfile=$base.d
+  # For projects that build the same source file twice into different object
+  # files, the pgcc approach of using the *source* file root name can cause
+  # problems in parallel builds.  Use a locking strategy to avoid stomping on
+  # the same $tmpdepfile.
+  lockdir=$base.d-lock
+  trap "
+    echo '$0: caught signal, cleaning up...' >&2
+    rmdir '$lockdir'
+    exit 1
+  " 1 2 13 15
+  numtries=100
+  i=$numtries
+  while test $i -gt 0; do
+    # mkdir is a portable test-and-set.
+    if mkdir "$lockdir" 2>/dev/null; then
+      # This process acquired the lock.
+      "$@" -MD
+      stat=$?
+      # Release the lock.
+      rmdir "$lockdir"
+      break
+    else
+      # If the lock is being held by a different process, wait
+      # until the winning process is done or we timeout.
+      while test -d "$lockdir" && test $i -gt 0; do
+        sleep 1
+        i=`expr $i - 1`
+      done
+    fi
+    i=`expr $i - 1`
+  done
+  trap - 1 2 13 15
+  if test $i -le 0; then
+    echo "$0: failed to acquire lock after $numtries attempts" >&2
+    echo "$0: check lockdir '$lockdir'" >&2
+    exit 1
+  fi
+  if test $stat -ne 0; then
+  "$@" -MD -MF "$tmpdepfile"
+  stat=$?
+  if test $stat -eq 0; then :
+  else
     rm -f "$tmpdepfile"
     exit $stat
 …
   # Some versions of the HPUX 10.20 sed can't process this invocation
   # correctly.  Breaking it into two sed invocations is a workaround.
   sed 's,^[^:]*: \(.*\)$,\1,;s/^\\$//;/^$/d;/:$/d' < "$tmpdepfile" \
     | sed -e 's/$/ :/' >> "$depfile"
+  sed 's,^[^:]*: \(.*\)$,\1,;s/^\\$//;/^$/d;/:$/d' < "$tmpdepfile" |
+    sed -e 's/$/ :/' >> "$depfile"
   rm -f "$tmpdepfile"
   ;;
 …
   # happens to be.
   # Much of this is similar to the tru64 case; see comments there.
+  set_dir_from  "$object"
+  set_base_from "$object"
+  dir=`echo "$object" | sed -e 's|/[^/]*$|/|'`
+  test "x$dir" = "x$object" && dir=
+  base=`echo "$object" | sed -e 's|^.*/||' -e 's/\.o$//' -e 's/\.lo$//'`
   if test "$libtool" = yes; then
     tmpdepfile1=$dir$base.d
 …
   fi
   stat=$?
+  if test $stat -ne 0; then
+  if test $stat -eq 0; then :
+  else
      rm -f "$tmpdepfile1" "$tmpdepfile2"
      exit $stat
 …
   done
   if test -f "$tmpdepfile"; then
     sed -e "s,^.*\.[$lower]*:,$object:," "$tmpdepfile" > "$depfile"
     # Add 'dependent.h:' lines.
+    sed -e "s,^.*\.[a-z]*:,$object:," "$tmpdepfile" > "$depfile"
+    # Add `dependent.h:' lines.
     sed -ne '2,${
                s/^ *//
                s/ \\*$//
                s/$/:/
+               p
              }' "$tmpdepfile" >> "$depfile"
   else
     make_dummy_depfile
+               s/^ *//
+               s/ \\*$//
+               s/$/:/
+               p
+             }' "$tmpdepfile" >> "$depfile"
+  else
+    echo "#dummy" > "$depfile"
   fi
   rm -f "$tmpdepfile" "$tmpdepfile2"
 …
 tru64)
+  # The Tru64 compiler uses -MD to generate dependencies as a side
+  # effect.  'cc -MD -o foo.o ...' puts the dependencies into 'foo.o.d'.
+  # At least on Alpha/Redhat 6.1, Compaq CCC V6.2-504 seems to put
+  # dependencies in 'foo.d' instead, so we check for that too.
+  # Subdirectories are respected.
+  set_dir_from  "$object"
+  set_base_from "$object"
+  if test "$libtool" = yes; then
+    # Libtool generates 2 separate objects for the 2 libraries.  These
+    # two compilations output dependencies in $dir.libs/$base.o.d and
+    # in $dir$base.o.d.  We have to check for both files, because
+    # one of the two compilations can be disabled.  We should prefer
+    # $dir$base.o.d over $dir.libs/$base.o.d because the latter is
+    # automatically cleaned when .libs/ is deleted, while ignoring
+    # the former would cause a distcleancheck panic.
+    tmpdepfile1=$dir$base.o.d          # libtool 1.5
+    tmpdepfile2=$dir.libs/$base.o.d    # Likewise.
+    tmpdepfile3=$dir.libs/$base.d      # Compaq CCC V6.2-504
+    "$@" -Wc,-MD
+  else
+    tmpdepfile1=$dir$base.d
+    tmpdepfile2=$dir$base.d
+    tmpdepfile3=$dir$base.d
+    "$@" -MD
+  fi
+  stat=$?
+  if test $stat -ne 0; then
+    rm -f "$tmpdepfile1" "$tmpdepfile2" "$tmpdepfile3"
+    exit $stat
+  fi
+  for tmpdepfile in "$tmpdepfile1" "$tmpdepfile2" "$tmpdepfile3"
+  do
+    test -f "$tmpdepfile" && break
+  done
+  # Same post-processing that is required for AIX mode.
+  aix_post_process_depfile
+  ;;
+   # The Tru64 compiler uses -MD to generate dependencies as a side
+   # effect.  `cc -MD -o foo.o ...' puts the dependencies into `foo.o.d'.
+   # At least on Alpha/Redhat 6.1, Compaq CCC V6.2-504 seems to put
+   # dependencies in `foo.d' instead, so we check for that too.
+   # Subdirectories are respected.
+   dir=`echo "$object" | sed -e 's|/[^/]*$|/|'`
+   test "x$dir" = "x$object" && dir=
+   base=`echo "$object" | sed -e 's|^.*/||' -e 's/\.o$//' -e 's/\.lo$//'`
+   if test "$libtool" = yes; then
+      # With Tru64 cc, shared objects can also be used to make a
+      # static library.  This mechanism is used in libtool 1.4 series to
+      # handle both shared and static libraries in a single compilation.
+      # With libtool 1.4, dependencies were output in $dir.libs/$base.lo.d.
+      #
+      # With libtool 1.5 this exception was removed, and libtool now
+      # generates 2 separate objects for the 2 libraries.  These two
+      # compilations output dependencies in $dir.libs/$base.o.d and
+      # in $dir$base.o.d.  We have to check for both files, because
+      # one of the two compilations can be disabled.  We should prefer
+      # $dir$base.o.d over $dir.libs/$base.o.d because the latter is
+      # automatically cleaned when .libs/ is deleted, while ignoring
+      # the former would cause a distcleancheck panic.
+      tmpdepfile1=$dir.libs/$base.lo.d   # libtool 1.4
+      tmpdepfile2=$dir$base.o.d          # libtool 1.5
+      tmpdepfile3=$dir.libs/$base.o.d    # libtool 1.5
+      tmpdepfile4=$dir.libs/$base.d      # Compaq CCC V6.2-504
+      "$@" -Wc,-MD
+   else
+      tmpdepfile1=$dir$base.o.d
+      tmpdepfile2=$dir$base.d
+      tmpdepfile3=$dir$base.d
+      tmpdepfile4=$dir$base.d
+      "$@" -MD
+   fi
+   stat=$?
+   if test $stat -eq 0; then :
+   else
+      rm -f "$tmpdepfile1" "$tmpdepfile2" "$tmpdepfile3" "$tmpdepfile4"
+      exit $stat
+   fi
+   for tmpdepfile in "$tmpdepfile1" "$tmpdepfile2" "$tmpdepfile3" "$tmpdepfile4"
+   do
+     test -f "$tmpdepfile" && break
+   done
+   if test -f "$tmpdepfile"; then
+      sed -e "s,^.*\.[a-z]*:,$object:," < "$tmpdepfile" > "$depfile"
+      # That's a tab and a space in the [].
+      sed -e 's,^.*\.[a-z]*:[    ]*,,' -e 's,$,:,' < "$tmpdepfile" >> "$depfile"
+   else
+      echo "#dummy" > "$depfile"
+   fi
+   rm -f "$tmpdepfile"
+   ;;
 msvc7)
 …
   stat=$?
   grep -v '^Note: including file: ' "$tmpdepfile"
+  if test $stat -ne 0; then
+  if test "$stat" = 0; then :
+  else
     rm -f "$tmpdepfile"
     exit $stat
 …
 }' | $cygpath_u | sort -u | sed -n '
 s/ /\\ /g
 s/\(.*\)/'"$tab"'\1 \\/p
+s/\(.*\)/       \1 \\/p
 s/.\(.*\) \\/\1:/
+H
 $ {
   s/.*/'"$tab"'/
+  s/.*/ /
+  G
+  p
 }' >> "$depfile"
-  echo >> "$depfile" # make sure the fragment doesn't end with a backslash
   rm -f "$tmpdepfile"
   ;;
 …
   fi
   # Remove '-o $object'.
+  # Remove `-o $object'.
   IFS=" "
   for arg
 …
   test -z "$dashmflag" && dashmflag=-M
   # Require at least two characters before searching for ':'
+  # Require at least two characters before searching for `:'
   # in the target name.  This is to cope with DOS-style filenames:
   # a dependency such as 'c:/foo/bar' could be seen as target 'c' otherwise.
+  # a dependency such as `c:/foo/bar' could be seen as target `c' otherwise.
   "$@" $dashmflag |
     sed "s|^[$tab ]*[^:$tab ][^:][^:]*:[$tab ]*|$object: |" > "$tmpdepfile"
+    sed 's:^[  ]*[^: ][^:][^:]*\:[    ]*:'"$object"'\: :' > "$tmpdepfile"
   rm -f "$depfile"
   cat < "$tmpdepfile" > "$depfile"
   # Some versions of the HPUX 10.20 sed can't process this sed invocation
+  # correctly.  Breaking it into two sed invocations is a workaround.
+  tr ' ' "$nl" < "$tmpdepfile" \
+    | sed -e 's/^\\$//' -e '/^$/d' -e '/:$/d' \
     | sed -e 's/$/ :/' >> "$depfile"
+  tr ' ' '
+' < "$tmpdepfile" | \
+## Some versions of the HPUX 10.20 sed can't process this invocation
+## correctly.  Breaking it into two sed invocations is a workaround.
+    sed -e 's/^\\$//' -e '/^$/d' -e '/:$/d' | sed -e 's/$/ :/' >> "$depfile"
   rm -f "$tmpdepfile"
   ;;
 …
   # No need to regex-escape $object, excess matching of '.' is harmless.
   sed "s|^.*\($object *:\)|\1|" "$tmpdepfile" > "$depfile"
+  # Some versions of the HPUX 10.20 sed can't process the last invocation
+  # correctly.  Breaking it into two sed invocations is a workaround.
+  sed '1,2d' "$tmpdepfile" \
+    | tr ' ' "$nl" \
+    | sed -e 's/^\\$//' -e '/^$/d' -e '/:$/d' \
+    | sed -e 's/$/ :/' >> "$depfile"
+  sed '1,2d' "$tmpdepfile" | tr ' ' '
+' | \
+## Some versions of the HPUX 10.20 sed can't process this invocation
+## correctly.  Breaking it into two sed invocations is a workaround.
+    sed -e 's/^\\$//' -e '/^$/d' -e '/:$/d' | sed -e 's/$/ :/' >> "$depfile"
   rm -f "$tmpdepfile" "$tmpdepfile".bak
   ;;
 …
   fi
   # Remove '-o $object'.
+  # Remove `-o $object'.
   IFS=" "
   for arg
 …
   done
   "$@" -E \
     | sed -n -e '/^# [0-9][0-9]* "\([^"]*\)".*/ s:: \1 \\:p' \
              -e '/^#line [0-9][0-9]* "\([^"]*\)".*/ s:: \1 \\:p' \
     | sed '$ s: \\$::' > "$tmpdepfile"
+  "$@" -E |
+    sed -n -e '/^# [0-9][0-9]* "\([^"]*\)".*/ s:: \1 \\:p' \
+       -e '/^#line [0-9][0-9]* "\([^"]*\)".*/ s:: \1 \\:p' |
+    sed '$ s: \\$::' > "$tmpdepfile"
   rm -f "$depfile"
   echo "$object : \\" > "$depfile"
 …
       ;;
     "-Gm"|"/Gm"|"-Gi"|"/Gi"|"-ZI"|"/ZI")
         set fnord "$@"
         shift
         shift
         ;;
+        set fnord "$@"
+        shift
+        shift
+        ;;
     *)
         set fnord "$@" "$arg"
         shift
         shift
         ;;
+        set fnord "$@" "$arg"
+        shift
+        shift
+        ;;
     esac
   done
 …
   rm -f "$depfile"
   echo "$object : \\" > "$depfile"
   sed < "$tmpdepfile" -n -e 's% %\\ %g' -e '/^\(.*\)$/ s::'"$tab"'\1 \\:p' >> "$depfile"
   echo "$tab" >> "$depfile"
+  sed < "$tmpdepfile" -n -e 's% %\\ %g' -e '/^\(.*\)$/ s::      \1 \\:p' >> "$depfile"
+  echo "        " >> "$depfile"
   sed < "$tmpdepfile" -n -e 's% %\\ %g' -e '/^\(.*\)$/ s::\1\::p' >> "$depfile"
   rm -f "$tmpdepfile"

automake/install-sh

-              r0720e049
+              r3d4b23fa
 # install - install a program, script, or datafile
 scriptversion=2014-09-12.12; # UTC
+scriptversion=2011-01-19.21; # UTC
 # This originates from X11R5 (mit/util/scripts/install.sh), which was
 …
+#
 # Calling this script install-sh is preferred over install.sh, to prevent
 # 'make' implicit rules from creating a file called install from it
+# `make' implicit rules from creating a file called install from it
 # when there is no Makefile.
+#
 …
 # from scratch.
-tab='   '
 nl='
+'
+IFS=" $tab$nl"
+# Set DOITPROG to "echo" to test this script.
+IFS=" ""        $nl"
+# set DOITPROG to echo to test this script
+# Don't use :- since 4.3BSD and earlier shells don't like it.
 doit=${DOITPROG-}
+doit_exec=${doit:-exec}
+if test -z "$doit"; then
+  doit_exec=exec
+else
+  doit_exec=$doit
+fi
 # Put in absolute file names if you don't have them in your path;
 …
 stripprog=${STRIPPROG-strip}
+posix_glob='?'
+initialize_posix_glob='
+  test "$posix_glob" != "?" || {
+    if (set -f) 2>/dev/null; then
+      posix_glob=
+    else
+      posix_glob=:
+    fi
+  }
+'
 posix_mkdir=
 …
 copy_on_change=false
+is_target_a_directory=possibly
+no_target_directory=
 usage="\
 …
     -g) chgrpcmd="$chgrpprog $2"
         shift;;
+        shift;;
     --help) echo "$usage"; exit $?;;
     -m) mode=$2
+        case $mode in
+          *' '* | *"$tab"* | *"$nl"* | *'*'* | *'?'* | *'['*)
+            echo "$0: invalid mode: $mode" >&2
+            exit 1;;
+        esac
+        shift;;
+        case $mode in
+          *' '* | *'    '* | *'
+'*        | *'*'* | *'?'* | *'['*)
+            echo "$0: invalid mode: $mode" >&2
+            exit 1;;
+        esac
+        shift;;
     -o) chowncmd="$chownprog $2"
         shift;;
+        shift;;
     -s) stripcmd=$stripprog;;
+    -t)
+        is_target_a_directory=always
+        dst_arg=$2
+        # Protect names problematic for 'test' and other utilities.
+        case $dst_arg in
+          -* | [=\(\)!]) dst_arg=./$dst_arg;;
+        esac
+        shift;;
+    -T) is_target_a_directory=never;;
+    -t) dst_arg=$2
+        # Protect names problematic for `test' and other utilities.
+        case $dst_arg in
+          -* | [=\(\)!]) dst_arg=./$dst_arg;;
+        esac
+        shift;;
+    -T) no_target_directory=true;;
     --version) echo "$0 $scriptversion"; exit $?;;
     --) shift
         break;;
     -*) echo "$0: invalid option: $1" >&2
         exit 1;;
+    --) shift
+        break;;
+    -*) echo "$0: invalid option: $1" >&2
+        exit 1;;
     *)  break;;
 …
   shift
 done
-# We allow the use of options -d and -T together, by making -d
-# take the precedence; this is for compatibility with GNU install.
-if test -n "$dir_arg"; then
-  if test -n "$dst_arg"; then
-    echo "$0: target directory not allowed when installing a directory." >&2
-    exit 1
-  fi
-fi
 if test $# -ne 0 && test -z "$dir_arg$dst_arg"; then
 …
     shift # arg
     dst_arg=$arg
     # Protect names problematic for 'test' and other utilities.
+    # Protect names problematic for `test' and other utilities.
     case $dst_arg in
       -* | [=\(\)!]) dst_arg=./$dst_arg;;
 …
     exit 1
   fi
   # It's OK to call 'install-sh -d' without argument.
+  # It's OK to call `install-sh -d' without argument.
   # This can happen when creating conditional directories.
   exit 0
-fi
-if test -z "$dir_arg"; then
-  if test $# -gt 1 || test "$is_target_a_directory" = always; then
-    if test ! -d "$dst_arg"; then
-      echo "$0: $dst_arg: Is not a directory." >&2
-      exit 1
-    fi
-  fi
 fi
 …
     *[0-7])
       if test -z "$stripcmd"; then
         u_plus_rw=
+        u_plus_rw=
       else
         u_plus_rw='% 200'
+        u_plus_rw='% 200'
       fi
       cp_umask=`expr '(' 777 - $mode % 1000 ')' $u_plus_rw`;;
     *)
       if test -z "$stripcmd"; then
         u_plus_rw=
+        u_plus_rw=
       else
         u_plus_rw=,u+rw
+        u_plus_rw=,u+rw
       fi
       cp_umask=$mode$u_plus_rw;;
 …
 for src
 do
   # Protect names problematic for 'test' and other utilities.
+  # Protect names problematic for `test' and other utilities.
   case $src in
     -* | [=\(\)!]) src=./$src;;
 …
     # if double slashes aren't ignored.
     if test -d "$dst"; then
       if test "$is_target_a_directory" = never; then
         echo "$0: $dst_arg: Is a directory" >&2
         exit 1
+      if test -n "$no_target_directory"; then
+        echo "$0: $dst_arg: Is a directory" >&2
+        exit 1
       fi
       dstdir=$dst
 …
       dstdir_status=0
     else
+      dstdir=`dirname "$dst"`
+      # Prefer dirname, but fall back on a substitute if dirname fails.
+      dstdir=`
+        (dirname "$dst") 2>/dev/null ||
+        expr X"$dst" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
+             X"$dst" : 'X\(//\)[^/]' \| \
+             X"$dst" : 'X\(//\)$' \| \
+             X"$dst" : 'X\(/\)' \| . 2>/dev/null ||
+        echo X"$dst" |
+            sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
+                   s//\1/
+                   q
+                 }
+                 /^X\(\/\/\)[^/].*/{
+                   s//\1/
+                   q
+                 }
+                 /^X\(\/\/\)$/{
+                   s//\1/
+                   q
+                 }
+                 /^X\(\/\).*/{
+                   s//\1/
+                   q
+                 }
+                 s/.*/./; q'
+      `
       test -d "$dstdir"
       dstdir_status=$?
 …
     case $posix_mkdir in
       '')
+        # Create intermediate dirs using mode 755 as modified by the umask.
+        # This is like FreeBSD 'install' as of 1997-10-28.
+        umask=`umask`
+        case $stripcmd.$umask in
+          # Optimize common cases.
+          *[2367][2367]) mkdir_umask=$umask;;
+          .*0[02][02] | .[02][02] | .[02]) mkdir_umask=22;;
+          *[0-7])
+            mkdir_umask=`expr $umask + 22 \
+              - $umask % 100 % 40 + $umask % 20 \
+              - $umask % 10 % 4 + $umask % 2
+            `;;
+          *) mkdir_umask=$umask,go-w;;
+        esac
+        # With -d, create the new directory with the user-specified mode.
+        # Otherwise, rely on $mkdir_umask.
+        if test -n "$dir_arg"; then
+          mkdir_mode=-m$mode
+        else
+          mkdir_mode=
+        fi
+        posix_mkdir=false
+        case $umask in
+          *[123567][0-7][0-7])
+            # POSIX mkdir -p sets u+wx bits regardless of umask, which
+            # is incompatible with FreeBSD 'install' when (umask & 300) != 0.
+            ;;
+          *)
+            # $RANDOM is not portable (e.g. dash);  use it when possible to
+            # lower collision chance
+            tmpdir=${TMPDIR-/tmp}/ins$RANDOM-$$
+            trap 'ret=$?; rmdir "$tmpdir/a/b" "$tmpdir/a" "$tmpdir" 2>/dev/null; exit $ret' 0
+            # As "mkdir -p" follows symlinks and we work in /tmp possibly;  so
+            # create the $tmpdir first (and fail if unsuccessful) to make sure
+            # that nobody tries to guess the $tmpdir name.
+            if (umask $mkdir_umask &&
+                $mkdirprog $mkdir_mode "$tmpdir" &&
+                exec $mkdirprog $mkdir_mode -p -- "$tmpdir/a/b") >/dev/null 2>&1
+            then
+              if test -z "$dir_arg" || {
+                   # Check for POSIX incompatibilities with -m.
+                   # HP-UX 11.23 and IRIX 6.5 mkdir -m -p sets group- or
+                   # other-writable bit of parent directory when it shouldn't.
+                   # FreeBSD 6.1 mkdir -m -p sets mode of existing directory.
+                   test_tmpdir="$tmpdir/a"
+                   ls_ld_tmpdir=`ls -ld "$test_tmpdir"`
+                   case $ls_ld_tmpdir in
+                     d????-?r-*) different_mode=700;;
+                     d????-?--*) different_mode=755;;
+                     *) false;;
+                   esac &&
+                   $mkdirprog -m$different_mode -p -- "$test_tmpdir" && {
+                     ls_ld_tmpdir_1=`ls -ld "$test_tmpdir"`
+                     test "$ls_ld_tmpdir" = "$ls_ld_tmpdir_1"
+                   }
+                 }
+              then posix_mkdir=:
+              fi
+              rmdir "$tmpdir/a/b" "$tmpdir/a" "$tmpdir"
+            else
+              # Remove any dirs left behind by ancient mkdir implementations.
+              rmdir ./$mkdir_mode ./-p ./-- "$tmpdir" 2>/dev/null
+            fi
+            trap '' 0;;
+        esac;;
+        # Create intermediate dirs using mode 755 as modified by the umask.
+        # This is like FreeBSD 'install' as of 1997-10-28.
+        umask=`umask`
+        case $stripcmd.$umask in
+          # Optimize common cases.
+          *[2367][2367]) mkdir_umask=$umask;;
+          .*0[02][02] | .[02][02] | .[02]) mkdir_umask=22;;
+          *[0-7])
+            mkdir_umask=`expr $umask + 22 \
+              - $umask % 100 % 40 + $umask % 20 \
+              - $umask % 10 % 4 + $umask % 2
+            `;;
+          *) mkdir_umask=$umask,go-w;;
+        esac
+        # With -d, create the new directory with the user-specified mode.
+        # Otherwise, rely on $mkdir_umask.
+        if test -n "$dir_arg"; then
+          mkdir_mode=-m$mode
+        else
+          mkdir_mode=
+        fi
+        posix_mkdir=false
+        case $umask in
+          *[123567][0-7][0-7])
+            # POSIX mkdir -p sets u+wx bits regardless of umask, which
+            # is incompatible with FreeBSD 'install' when (umask & 300) != 0.
+            ;;
+          *)
+            tmpdir=${TMPDIR-/tmp}/ins$RANDOM-$$
+            trap 'ret=$?; rmdir "$tmpdir/d" "$tmpdir" 2>/dev/null; exit $ret' 0
+            if (umask $mkdir_umask &&
+                exec $mkdirprog $mkdir_mode -p -- "$tmpdir/d") >/dev/null 2>&1
+            then
+              if test -z "$dir_arg" || {
+                   # Check for POSIX incompatibilities with -m.
+                   # HP-UX 11.23 and IRIX 6.5 mkdir -m -p sets group- or
+                   # other-writeable bit of parent directory when it shouldn't.
+                   # FreeBSD 6.1 mkdir -m -p sets mode of existing directory.
+                   ls_ld_tmpdir=`ls -ld "$tmpdir"`
+                   case $ls_ld_tmpdir in
+                     d????-?r-*) different_mode=700;;
+                     d????-?--*) different_mode=755;;
+                     *) false;;
+                   esac &&
+                   $mkdirprog -m$different_mode -p -- "$tmpdir" && {
+                     ls_ld_tmpdir_1=`ls -ld "$tmpdir"`
+                     test "$ls_ld_tmpdir" = "$ls_ld_tmpdir_1"
+                   }
+                 }
+              then posix_mkdir=:
+              fi
+              rmdir "$tmpdir/d" "$tmpdir"
+            else
+              # Remove any dirs left behind by ancient mkdir implementations.
+              rmdir ./$mkdir_mode ./-p ./-- 2>/dev/null
+            fi
+            trap '' 0;;
+        esac;;
     esac
     if
       $posix_mkdir && (
         umask $mkdir_umask &&
         $doit_exec $mkdirprog $mkdir_mode -p -- "$dstdir"
+        umask $mkdir_umask &&
+        $doit_exec $mkdirprog $mkdir_mode -p -- "$dstdir"
+      )
     then :
 …
       case $dstdir in
         /*) prefix='/';;
         [-=\(\)!]*) prefix='./';;
         *)  prefix='';;
+        /*) prefix='/';;
+        [-=\(\)!]*) prefix='./';;
+        *)  prefix='';;
       esac
+      eval "$initialize_posix_glob"
       oIFS=$IFS
       IFS=/
       set -f
+      $posix_glob set -f
       set fnord $dstdir
       shift
       set +f
+      $posix_glob set +f
       IFS=$oIFS
 …
       for d
       do
         test X"$d" = X && continue
         prefix=$prefix$d
         if test -d "$prefix"; then
           prefixes=
         else
           if $posix_mkdir; then
             (umask=$mkdir_umask &&
              $doit_exec $mkdirprog $mkdir_mode -p -- "$dstdir") && break
             # Don't fail if two instances are running concurrently.
             test -d "$prefix" || exit 1
           else
             case $prefix in
               *\'*) qprefix=`echo "$prefix" | sed "s/'/'\\\\\\\\''/g"`;;
               *) qprefix=$prefix;;
             esac
             prefixes="$prefixes '$qprefix'"
           fi
         fi
         prefix=$prefix/
+        test X"$d" = X && continue
+        prefix=$prefix$d
+        if test -d "$prefix"; then
+          prefixes=
+        else
+          if $posix_mkdir; then
+            (umask=$mkdir_umask &&
+             $doit_exec $mkdirprog $mkdir_mode -p -- "$dstdir") && break
+            # Don't fail if two instances are running concurrently.
+            test -d "$prefix" || exit 1
+          else
+            case $prefix in
+              *\'*) qprefix=`echo "$prefix" | sed "s/'/'\\\\\\\\''/g"`;;
+              *) qprefix=$prefix;;
+            esac
+            prefixes="$prefixes '$qprefix'"
+          fi
+        fi
+        prefix=$prefix/
       done
       if test -n "$prefixes"; then
         # Don't fail if two instances are running concurrently.
         (umask $mkdir_umask &&
          eval "\$doit_exec \$mkdirprog $prefixes") ||
           test -d "$dstdir" || exit 1
         obsolete_mkdir_used=true
+        # Don't fail if two instances are running concurrently.
+        (umask $mkdir_umask &&
+         eval "\$doit_exec \$mkdirprog $prefixes") ||
+          test -d "$dstdir" || exit 1
+        obsolete_mkdir_used=true
       fi
     fi
 …
     # If -C, don't bother to copy if it wouldn't change the file.
     if $copy_on_change &&
+       old=`LC_ALL=C ls -dlL "$dst"     2>/dev/null` &&
+       new=`LC_ALL=C ls -dlL "$dsttmp"  2>/dev/null` &&
+       set -f &&
+       old=`LC_ALL=C ls -dlL "$dst"     2>/dev/null` &&
+       new=`LC_ALL=C ls -dlL "$dsttmp"  2>/dev/null` &&
+       eval "$initialize_posix_glob" &&
+       $posix_glob set -f &&
        set X $old && old=:$2:$4:$5:$6 &&
        set X $new && new=:$2:$4:$5:$6 &&
+       set +f &&
+       $posix_glob set +f &&
        test "$old" = "$new" &&
        $cmpprog "$dst" "$dsttmp" >/dev/null 2>&1
 …
       # support -f.
+      {
         # Now remove or move aside any old file at destination location.
         # We try this two ways since rm can't unlink itself on some
         # systems and the destination file might be busy for other
         # reasons.  In this case, the final cleanup might fail but the new
         # file should still install successfully.
+        {
           test ! -f "$dst" ||
           $doit $rmcmd -f "$dst" 2>/dev/null ||
           { $doit $mvcmd -f "$dst" "$rmtmp" 2>/dev/null &&
             { $doit $rmcmd -f "$rmtmp" 2>/dev/null; :; }
           } ||
           { echo "$0: cannot unlink or rename $dst" >&2
             (exit 1); exit 1
+          }
         } &&
         # Now rename the file to the real destination.
         $doit $mvcmd "$dsttmp" "$dst"
+        # Now remove or move aside any old file at destination location.
+        # We try this two ways since rm can't unlink itself on some
+        # systems and the destination file might be busy for other
+        # reasons.  In this case, the final cleanup might fail but the new
+        # file should still install successfully.
+        {
+          test ! -f "$dst" ||
+          $doit $rmcmd -f "$dst" 2>/dev/null ||
+          { $doit $mvcmd -f "$dst" "$rmtmp" 2>/dev/null &&
+            { $doit $rmcmd -f "$rmtmp" 2>/dev/null; :; }
+          } ||
+          { echo "$0: cannot unlink or rename $dst" >&2
+            (exit 1); exit 1
+          }
+        } &&
+        # Now rename the file to the real destination.
+        $doit $mvcmd "$dsttmp" "$dst"
+      }
     fi || exit 1

automake/test-driver

Property mode changed from 100755 to 120000

-              r0720e049
+              r3d4b23fa
+#! /bin/sh
+# test-driver - basic testsuite driver script.
+scriptversion=2013-07-13.22; # UTC
+# Copyright (C) 2011-2014 Free Software Foundation, Inc.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2, or (at your option)
+# any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+# As a special exception to the GNU General Public License, if you
+# distribute this file as part of a program that contains a
+# configuration script generated by Autoconf, you may include it under
+# the same distribution terms that you use for the rest of that program.
+# This file is maintained in Automake, please report
+# bugs to <bug-automake@gnu.org> or send patches to
+# <automake-patches@gnu.org>.
+# Make unconditional expansion of undefined variables an error.  This
+# helps a lot in preventing typo-related bugs.
+set -u
+usage_error ()
+{
+  echo "$0: $*" >&2
+  print_usage >&2
+  exit 2
+}
+print_usage ()
+{
+  cat <<END
+Usage:
+  test-driver --test-name=NAME --log-file=PATH --trs-file=PATH
+              [--expect-failure={yes|no}] [--color-tests={yes|no}]
+              [--enable-hard-errors={yes|no}] [--]
+              TEST-SCRIPT [TEST-SCRIPT-ARGUMENTS]
+The '--test-name', '--log-file' and '--trs-file' options are mandatory.
+END
+}
+test_name= # Used for reporting.
+log_file=  # Where to save the output of the test script.
+trs_file=  # Where to save the metadata of the test run.
+expect_failure=no
+color_tests=no
+enable_hard_errors=yes
+while test $# -gt 0; do
+  case $1 in
+  --help) print_usage; exit $?;;
+  --version) echo "test-driver $scriptversion"; exit $?;;
+  --test-name) test_name=$2; shift;;
+  --log-file) log_file=$2; shift;;
+  --trs-file) trs_file=$2; shift;;
+  --color-tests) color_tests=$2; shift;;
+  --expect-failure) expect_failure=$2; shift;;
+  --enable-hard-errors) enable_hard_errors=$2; shift;;
+  --) shift; break;;
+  -*) usage_error "invalid option: '$1'";;
+   *) break;;
+  esac
+  shift
+done
+missing_opts=
+test x"$test_name" = x && missing_opts="$missing_opts --test-name"
+test x"$log_file"  = x && missing_opts="$missing_opts --log-file"
+test x"$trs_file"  = x && missing_opts="$missing_opts --trs-file"
+if test x"$missing_opts" != x; then
+  usage_error "the following mandatory options are missing:$missing_opts"
+fi
+if test $# -eq 0; then
+  usage_error "missing argument"
+fi
+if test $color_tests = yes; then
+  # Keep this in sync with 'lib/am/check.am:$(am__tty_colors)'.
+  red='[0;31m' # Red.
+  grn='[0;32m' # Green.
+  lgn='[1;32m' # Light green.
+  blu='[1;34m' # Blue.
+  mgn='[0;35m' # Magenta.
+  std='[m'     # No color.
+else
+  red= grn= lgn= blu= mgn= std=
+fi
+do_exit='rm -f $log_file $trs_file; (exit $st); exit $st'
+trap "st=129; $do_exit" 1
+trap "st=130; $do_exit" 2
+trap "st=141; $do_exit" 13
+trap "st=143; $do_exit" 15
+# Test script is run here.
+"$@" >$log_file 2>&1
+estatus=$?
+if test $enable_hard_errors = no && test $estatus -eq 99; then
+  tweaked_estatus=1
+else
+  tweaked_estatus=$estatus
+fi
+case $tweaked_estatus:$expect_failure in
+:yes) col=$red res=XPASS recheck=yes gcopy=yes;;
+:*)   col=$grn res=PASS  recheck=no  gcopy=no;;
+:*)  col=$blu res=SKIP  recheck=no  gcopy=yes;;
+:*)  col=$mgn res=ERROR recheck=yes gcopy=yes;;
+  *:yes) col=$lgn res=XFAIL recheck=no  gcopy=yes;;
+  *:*)   col=$red res=FAIL  recheck=yes gcopy=yes;;
+esac
+# Report the test outcome and exit status in the logs, so that one can
+# know whether the test passed or failed simply by looking at the '.log'
+# file, without the need of also peaking into the corresponding '.trs'
+# file (automake bug#11814).
+echo "$res $test_name (exit status: $estatus)" >>$log_file
+# Report outcome to console.
+echo "${col}${res}${std}: $test_name"
+# Register the test result, and other relevant metadata.
+echo ":test-result: $res" > $trs_file
+echo ":global-test-result: $res" >> $trs_file
+echo ":recheck: $recheck" >> $trs_file
+echo ":copy-in-global-log: $gcopy" >> $trs_file
+# Local Variables:
+# mode: shell-script
+# sh-indentation: 2
+# eval: (add-hook 'write-file-hooks 'time-stamp)
+# time-stamp-start: "scriptversion="
+# time-stamp-format: "%:y-%02m-%02d.%02H"
+# time-stamp-time-zone: "UTC"
+# time-stamp-end: "; # UTC"
+# End:
+/usr/share/automake-1.15/test-driver

automake/ylwrap

-              r0720e049
+              r3d4b23fa
 # ylwrap - wrapper for lex/yacc invocations.
+scriptversion=2013-01-12.17; # UTC
+# Copyright (C) 1996-2014 Free Software Foundation, Inc.
+scriptversion=2011-08-25.18; # UTC
+# Copyright (C) 1996, 1997, 1998, 1999, 2001, 2002, 2003, 2004, 2005,
+# 2007, 2009, 2010, 2011 Free Software Foundation, Inc.
+#
 # Written by Tom Tromey <tromey@cygnus.com>.
 …
 # <automake-patches@gnu.org>.
-get_dirname ()
+{
-  case $1 in
-    */*|*\\*) printf '%s\n' "$1" | sed -e 's|\([\\/]\)[^\\/]*$|\1|';;
-    # Otherwise,  we want the empty string (not ".").
-  esac
+}
-# guard FILE
-# ----------
-# The CPP macro used to guard inclusion of FILE.
-guard ()
+{
-  printf '%s\n' "$1"                                                    \
-    | sed                                                               \
-        -e 'y/abcdefghijklmnopqrstuvwxyz/ABCDEFGHIJKLMNOPQRSTUVWXYZ/'   \
-        -e 's/[^ABCDEFGHIJKLMNOPQRSTUVWXYZ]/_/g'                        \
-        -e 's/__*/_/g'
+}
-# quote_for_sed [STRING]
-# ----------------------
-# Return STRING (or stdin) quoted to be used as a sed pattern.
-quote_for_sed ()
+{
-  case $# in
-) cat;;
-) printf '%s\n' "$1";;
-  esac \
-    | sed -e 's|[][\\.*]|\\&|g'
+}
 case "$1" in
   '')
     echo "$0: No files given.  Try '$0 --help' for more information." 1>&2
+    echo "$0: No files given.  Try \`$0 --help' for more information." 1>&2
     exit 1
     ;;
 …
 # The input.
 input=$1
+input="$1"
 shift
+# We'll later need for a correct munging of "#line" directives.
+input_sub_rx=`get_dirname "$input" | quote_for_sed`
+case $input in
+case "$input" in
   [\\/]* | ?:[\\/]*)
     # Absolute path; do nothing.
 …
   *)
     # Relative path.  Make it absolute.
+    input=`pwd`/$input
+    ;;
+esac
+input_rx=`get_dirname "$input" | quote_for_sed`
+# Since DOS filename conventions don't allow two dots,
+# the DOS version of Bison writes out y_tab.c instead of y.tab.c
+# and y_tab.h instead of y.tab.h. Test to see if this is the case.
+y_tab_nodot=false
+if test -f y_tab.c || test -f y_tab.h; then
+  y_tab_nodot=true
+fi
+# The parser itself, the first file, is the destination of the .y.c
+# rule in the Makefile.
+parser=$1
+# A sed program to s/FROM/TO/g for all the FROM/TO so that, for
+# instance, we rename #include "y.tab.h" into #include "parse.h"
+# during the conversion from y.tab.c to parse.c.
+sed_fix_filenames=
+# Also rename header guards, as Bison 2.7 for instance uses its header
+# guard in its implementation file.
+sed_fix_header_guards=
+while test $# -ne 0; do
+  if test x"$1" = x"--"; then
+    input="`pwd`/$input"
+    ;;
+esac
+pairlist=
+while test "$#" -ne 0; do
+  if test "$1" = "--"; then
     shift
     break
   fi
+  from=$1
+  # Handle y_tab.c and y_tab.h output by DOS
+  if $y_tab_nodot; then
+    case $from in
+      "y.tab.c") from=y_tab.c;;
+      "y.tab.h") from=y_tab.h;;
+    esac
+  fi
+  pairlist="$pairlist $1"
   shift
-  to=$1
-  shift
-  sed_fix_filenames="${sed_fix_filenames}s|"`quote_for_sed "$from"`"|$to|g;"
-  sed_fix_header_guards="${sed_fix_header_guards}s|"`guard "$from"`"|"`guard "$to"`"|g;"
 done
 # The program to run.
 prog=$1
+prog="$1"
 shift
 # Make any relative path in $prog absolute.
 case $prog in
+case "$prog" in
   [\\/]* | ?:[\\/]*) ;;
+  *[\\/]*) prog=`pwd`/$prog ;;
+esac
+  *[\\/]*) prog="`pwd`/$prog" ;;
+esac
+# FIXME: add hostname here for parallel makes that run commands on
+# other machines.  But that might take us over the 14-char limit.
 dirname=ylwrap$$
 do_exit="cd '`pwd`' && rm -rf $dirname > /dev/null 2>&1;"' (exit $ret); exit $ret'
 …
 if test $ret -eq 0; then
+  for from in *
+  do
+    to=`printf '%s\n' "$from" | sed "$sed_fix_filenames"`
+  set X $pairlist
+  shift
+  first=yes
+  # Since DOS filename conventions don't allow two dots,
+  # the DOS version of Bison writes out y_tab.c instead of y.tab.c
+  # and y_tab.h instead of y.tab.h. Test to see if this is the case.
+  y_tab_nodot="no"
+  if test -f y_tab.c || test -f y_tab.h; then
+    y_tab_nodot="yes"
+  fi
+  # The directory holding the input.
+  input_dir=`echo "$input" | sed -e 's,\([\\/]\)[^\\/]*$,\1,'`
+  # Quote $INPUT_DIR so we can use it in a regexp.
+  # FIXME: really we should care about more than `.' and `\'.
+  input_rx=`echo "$input_dir" | sed 's,\\\\,\\\\\\\\,g;s,\\.,\\\\.,g'`
+  while test "$#" -ne 0; do
+    from="$1"
+    # Handle y_tab.c and y_tab.h output by DOS
+    if test $y_tab_nodot = "yes"; then
+      if test $from = "y.tab.c"; then
+        from="y_tab.c"
+      else
+        if test $from = "y.tab.h"; then
+          from="y_tab.h"
+        fi
+      fi
+    fi
     if test -f "$from"; then
       # If $2 is an absolute path name, then just use that,
       # otherwise prepend '../'.
       case $to in
         [\\/]* | ?:[\\/]*) target=$to;;
         *) target=../$to;;
+      # otherwise prepend `../'.
+      case "$2" in
+        [\\/]* | ?:[\\/]*) target="$2";;
+        *) target="../$2";;
       esac
+      # Do not overwrite unchanged header files to avoid useless
+      # recompilations.  Always update the parser itself: it is the
+      # destination of the .y.c rule in the Makefile.  Divert the
+      # output of all other files to a temporary file so we can
+      # compare them to existing versions.
+      if test $from != $parser; then
+        realtarget=$target
+        target=tmp-`printf '%s\n' "$target" | sed 's|.*[\\/]||g'`
+      fi
+      # Munge "#line" or "#" directives.  Don't let the resulting
+      # debug information point at an absolute srcdir.  Use the real
+      # output file name, not yy.lex.c for instance.  Adjust the
+      # include guards too.
+      sed -e "/^#/!b"                           \
+          -e "s|$input_rx|$input_sub_rx|"       \
+          -e "$sed_fix_filenames"               \
+          -e "$sed_fix_header_guards"           \
+        "$from" >"$target" || ret=$?
+      # Check whether files must be updated.
+      if test "$from" != "$parser"; then
+      # We do not want to overwrite a header file if it hasn't
+      # changed.  This avoid useless recompilations.  However the
+      # parser itself (the first file) should always be updated,
+      # because it is the destination of the .y.c rule in the
+      # Makefile.  Divert the output of all other files to a temporary
+      # file so we can compare them to existing versions.
+      if test $first = no; then
+        realtarget="$target"
+        target="tmp-`echo $target | sed s/.*[\\/]//g`"
+      fi
+      # Edit out `#line' or `#' directives.
+      #
+      # We don't want the resulting debug information to point at
+      # an absolute srcdir; it is better for it to just mention the
+      # .y file with no path.
+      #
+      # We want to use the real output file name, not yy.lex.c for
+      # instance.
+      #
+      # We want the include guards to be adjusted too.
+      FROM=`echo "$from" | sed \
+            -e 'y/abcdefghijklmnopqrstuvwxyz/ABCDEFGHIJKLMNOPQRSTUVWXYZ/'\
+            -e 's/[^ABCDEFGHIJKLMNOPQRSTUVWXYZ]/_/g'`
+      TARGET=`echo "$2" | sed \
+            -e 'y/abcdefghijklmnopqrstuvwxyz/ABCDEFGHIJKLMNOPQRSTUVWXYZ/'\
+            -e 's/[^ABCDEFGHIJKLMNOPQRSTUVWXYZ]/_/g'`
+      sed -e "/^#/!b" -e "s,$input_rx,," -e "s,$from,$2," \
+          -e "s,$FROM,$TARGET," "$from" >"$target" || ret=$?
+      # Check whether header files must be updated.
+      if test $first = no; then
         if test -f "$realtarget" && cmp -s "$realtarget" "$target"; then
           echo "$to is unchanged"
+          echo "$2" is unchanged
           rm -f "$target"
         else
           echo "updating $to"
+          echo updating "$2"
           mv -f "$target" "$realtarget"
         fi
       fi
     else
+      # A missing file is only an error for the parser.  This is a
+      # blatant hack to let us support using "yacc -d".  If -d is not
+      # specified, don't fail when the header file is "missing".
+      if test "$from" = "$parser"; then
+      # A missing file is only an error for the first file.  This
+      # is a blatant hack to let us support using "yacc -d".  If -d
+      # is not specified, we don't want an error when the header
+      # file is "missing".
+      if test $first = yes; then
         ret=1
       fi
     fi
+    shift
+    shift
+    first=no
   done
+else
+  ret=$?
 fi

configure

-              r0720e049
+              r3d4b23fa
         case $host_cpu in
                 i386)
                         CFLAGS+=" -m32 "
                         CXXFLAGS+=" -m32 "
                         CFAFLAGS+=" -m32 "
                         LDFLAGS+=" -m32 "
+                        CFLAGS+="-m32"
+                        CXXFLAGS+="-m32"
+                        CFAFLAGS+="-m32"
+                        LDFLAGS+="-m32"
                         ;;
                 i686)
                         CFLAGS+=" -m32 "
                   CXXFLAGS+=" -m32 "
                   CFAFLAGS+=" -m32 "
                   LDFLAGS+=" -m32 "
+                        CFLAGS+="-m32"
+                        CXXFLAGS+="-m32"
+                        CFAFLAGS+="-m32"
+                        LDFLAGS+="-m32"
                         ;;
                 x86_64)
                         CFLAGS+=" -m64 "
                         CXXFLAGS+=" -m64 "
                         CFAFLAGS+=" -m64 "
                         LDFLAGS+=" -m64 "
+                        CFLAGS+="-m64"
+                        CXXFLAGS+="-m64"
+                        CFAFLAGS+="-m64"
+                        LDFLAGS+="-m64"
                         ;;
         esac

configure.ac

-              r0720e049
+              r3d4b23fa
 AC_SUBST([MACHINE_TYPE],[$host_cpu])
 if ! test "$host_cpu" = "$build_cpu"; then
+if ! test "$host_cpu" = "$build_cpu"; then
         case $host_cpu in
                 i386)
                         CFLAGS+=" -m32 "
                         CXXFLAGS+=" -m32 "
                         CFAFLAGS+=" -m32 "
                         LDFLAGS+=" -m32 "
+                        CFLAGS+="-m32"
+                        CXXFLAGS+="-m32"
+                        CFAFLAGS+="-m32"
+                        LDFLAGS+="-m32"
                         ;;
                 i686)
                         CFLAGS+=" -m32 "
                   CXXFLAGS+=" -m32 "
                   CFAFLAGS+=" -m32 "
                   LDFLAGS+=" -m32 "
+                        CFLAGS+="-m32"
+                        CXXFLAGS+="-m32"
+                        CFAFLAGS+="-m32"
+                        LDFLAGS+="-m32"
                         ;;
                 x86_64)
                         CFLAGS+=" -m64 "
                         CXXFLAGS+=" -m64 "
                         CFAFLAGS+=" -m64 "
                         LDFLAGS+=" -m64 "
+                        CFLAGS+="-m64"
+                        CXXFLAGS+="-m64"
+                        CFAFLAGS+="-m64"
+                        LDFLAGS+="-m64"
                         ;;
         esac

doc/LaTeXmacros/common.tex

-              r0720e049
+              r3d4b23fa
 %% Created On       : Sat Apr  9 10:06:17 2016
 %% Last Modified By : Peter A. Buhr
 %% Last Modified On : Mon Jul 24 21:02:14 2017
 %% Update Count     : 352
+%% Last Modified On : Thu Jul 13 11:44:59 2017
+%% Update Count     : 335
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 …
 % inline text and code index (cannot use ©)
 \newcommand{\Indexc}[2][\@empty]{\lstinline[#1]$#2$\index{#2@\lstinline[#1]$#2$}}
+\newcommand{\Indexc}[1]{\lstinline$#1$\index{#1@\lstinline$#1$}}
 % code index (cannot use ©)
 \newcommand{\indexc}[2][\@empty]{\index{#2@\lstinline[#1]$#2$}}
+\newcommand{\indexc}[1]{\index{#1@\lstinline$#1$}}
 % Denote newterms in particular font and index them without particular font and in lowercase, e.g., \newterm{abc}.
 …
 basicstyle=\linespread{0.9}\sf,                                                 % reduce line spacing and use sanserif font
 stringstyle=\tt,                                                                                % use typewriter font
 tabsize=5,                                                                                              % N space tabbing
+tabsize=6,                                                                                              % N space tabbing
 xleftmargin=\parindentlnth,                                                             % indent code to paragraph indentation
 extendedchars=true,                                                                             % allow ASCII characters in the range 128-255

doc/LaTeXmacros/lstlang.sty

-              r0720e049
+              r3d4b23fa
 %% Created On       : Sat May 13 16:34:42 2017
 %% Last Modified By : Peter A. Buhr
 %% Last Modified On : Mon Jul 24 20:40:37 2017
 %% Update Count     : 13
+%% Last Modified On : Wed Jul 12 22:42:09 2017
+%% Update Count     : 12
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 …
                 finally, forall, ftype, _Generic, _Imaginary, inline, __label__, lvalue, _Noreturn, one_t,
                 otype, restrict, _Static_assert, throw, throwResume, trait, try, ttype, typeof, __typeof,
                 __typeof__, virtual, with, zero_t},
+                __typeof__, with, zero_t},
         morekeywords=[2]{
                 _Atomic, coroutine, is_coroutine, is_monitor, is_thread, monitor, mutex, nomutex,

doc/generic_types/generic_types.tex

-              r0720e049
+              r3d4b23fa
 % Useful macros
 \newcommand{\CFAIcon}{\textsf{C}\raisebox{\depth}{\rotatebox{180}{\textsf{A}}}\xspace} % Cforall symbolic name
+\newcommand{\CFA}{\protect\CFAIcon} % safe for section/caption
 \newcommand{\CC}{\textrm{C}\kern-.1em\hbox{+\kern-.25em+}\xspace} % C++ symbolic name
 \newcommand{\CCeleven}{\textrm{C}\kern-.1em\hbox{+\kern-.25em+}11\xspace} % C++11 symbolic name
 \newcommand{\CCfourteen}{\textrm{C}\kern-.1em\hbox{+\kern-.25em+}14\xspace} % C++14 symbolic name
 \newcommand{\CCseventeen}{\textrm{C}\kern-.1em\hbox{+\kern-.25em+}17\xspace} % C++17 symbolic name
 \newcommand{\CCtwenty}{\textrm{C}\kern-.1em\hbox{+\kern-.25em+}20\xspace} % C++20 symbolic name
+\newcommand{\CFA}{C\raisebox{\depth}{\rotatebox{180}{\textsf{A}}}\hspace{-1pt}\xspace} % Cforall symbolic name
+%\newcommand{\CFA}{C$\mathbf\forall$\xspace} % Cforall symbolic name
+\newcommand{\CC}{\rm C\kern-.1em\hbox{+\kern-.25em+}\xspace} % C++ symbolic name
+\newcommand{\CCeleven}{\rm C\kern-.1em\hbox{+\kern-.25em+}11\xspace} % C++11 symbolic name
+\newcommand{\CCfourteen}{\rm C\kern-.1em\hbox{+\kern-.25em+}14\xspace} % C++14 symbolic name
+\newcommand{\CCseventeen}{\rm C\kern-.1em\hbox{+\kern-.25em+}17\xspace} % C++17 symbolic name
+\newcommand{\CCtwenty}{\rm C\kern-.1em\hbox{+\kern-.25em+}20\xspace} % C++20 symbolic name
 \newcommand{\CCV}{\rm C\kern-.1em\hbox{+\kern-.25em+}obj\xspace} % C++ virtual symbolic name
 \newcommand{\Csharp}{C\raisebox{-0.7ex}{\Large$^\sharp$}\xspace} % C# symbolic name
 …
 This function could acquire the layout for @set(T)@ by calling its layout function with the layout of @T@ implicitly passed into the function.
 Whether a type is concrete, dtype-static, or dynamic is decided solely on the @forall@'s type parameters.
 This design allows opaque forward declarations of generic types, \eg @forall(otype T)@ @struct Box@ -- like in C, all uses of @Box(T)@ can be separately compiled, and callers from other translation units know the proper calling conventions to use.
 If the definition of a structure type is included in deciding whether a generic type is dynamic or concrete, some further types may be recognized as dtype-static (\eg @forall(otype T)@ @struct unique_ptr { T * p }@ does not depend on @T@ for its layout, but the existence of an @otype@ parameter means that it \emph{could}.), but preserving separate compilation (and the associated C compatibility) in the existing design is judged to be an appropriate trade-off.
+Whether a type is concrete, dtype-static, or dynamic is decided solely on the type parameters and @forall@ clause on a declaration.
+This design allows opaque forward declarations of generic types, \eg @forall(otype T) struct Box@ -- like in C, all uses of @Box(T)@ can be separately compiled, and callers from other translation units know the proper calling conventions to use.
+If the definition of a structure type is included in deciding whether a generic type is dynamic or concrete, some further types may be recognized as dtype-static (\eg @forall(otype T) struct unique_ptr { T * p }@ does not depend on @T@ for its layout, but the existence of an @otype@ parameter means that it \emph{could}.), but preserving separate compilation (and the associated C compatibility) in the existing design is judged to be an appropriate trade-off.
 …
+}
 \end{lstlisting}
-\begin{sloppypar}
 Tuple expressions are then simply converted directly into compound literals, \eg @[5, 'x', 1.24]@ becomes @(_tuple3(int, char, double)){ 5, 'x', 1.24 }@.
-\end{sloppypar}
 \begin{comment}

doc/proposals/concurrency/text/concurrency.tex

-              r0720e049
+              r3d4b23fa
 % ======================================================================
 % ======================================================================
 Several tool can be used to solve concurrency challenges. Since many of these challenges appear with the use of mutable shared-state, some languages and libraries simply disallow mutable shared-state (Erlang~\cite{Erlang}, Haskell~\cite{Haskell}, Akka (Scala)~\cite{Akka}). In these paradigms, interaction among concurrent objects relies on message passing~\cite{Thoth,Harmony,V-Kernel} or other paradigms that closely relate to networking concepts (channels\cit for example). However, in languages that use routine calls as their core abstraction-mechanism, these approaches force a clear distinction between concurrent and non-concurrent paradigms (i.e., message passing versus routine call). This distinction in turn means that, in order to be effective, programmers need to learn two sets of designs patterns. While this distinction can be hidden away in library code, effective use of the librairy still has to take both paradigms into account.
 Approaches based on shared memory are more closely related to non-concurrent paradigms since they often rely on basic constructs like routine calls and shared objects. At the lowest level, concurrent paradigms are implemented as atomic operations and locks. Many such mechanisms have been proposed, including semaphores~\cite{Dijkstra68b} and path expressions~\cite{Campbell74}. However, for productivity reasons it is desireable to have a higher-level construct be the core concurrency paradigm~\cite{HPP:Study}.
 An approach that is worth mentionning because it is gaining in popularity is transactionnal memory~\cite{Dice10}[Check citation]. While this approach is even pursued by system languages like \CC\cit, the performance and feature set is currently too restrictive to be the main concurrency paradigm for general purpose language, which is why it was rejected as the core paradigm for concurrency in \CFA.
+Several tool can be used to solve concurrency challenges. Since many of these challenges appear with the use of mutable shared-state, some languages and libraries simply disallow mutable shared-state (Erlang~\cite{Erlang}, Haskell~\cite{Haskell}, Akka (Scala)~\cite{Akka}). In these paradigms, interaction among concurrent objects relies on message passing~\cite{Thoth,Harmony,V-Kernel} or other paradigms that closely relate to networking concepts (channels\cit for example). However, in languages that use routine calls as their core abstraction-mechanism, these approaches force a clear distinction between concurrent and non-concurrent paradigms (i.e., message passing versus routine call). This distinction in turn means that, in order to be effective, programmers need to learn two sets of designs patterns. While this distinction can be hidden away in library code, effective use of the librairy still has to take both paradigms into account.
+Approaches based on shared memory are more closely related to non-concurrent paradigms since they often rely on basic constructs like routine calls and shared objects. At the lowest level, concurrent paradigms are implemented as atomic operations and locks. Many such mechanisms have been proposed, including semaphores~\cite{Dijkstra68b} and path expressions~\cite{Campbell74}. However, for productivity reasons it is desireable to have a higher-level construct be the core concurrency paradigm~\cite{HPP:Study}.
+An approach that is worth mentionning because it is gaining in popularity is transactionnal memory~\cite{Dice10}[Check citation]. While this approach is even pursued by system languages like \CC\cit, the performance and feature set is currently too restrictive to be the main concurrency paradigm for general purpose language, which is why it was rejected as the core paradigm for concurrency in \CFA.
 One of the most natural, elegant, and efficient mechanisms for synchronization and communication, especially for shared memory systems, is the \emph{monitor}. Monitors were first proposed by Brinch Hansen~\cite{Hansen73} and later described and extended by C.A.R.~Hoare~\cite{Hoare74}. Many programming languages---e.g., Concurrent Pascal~\cite{ConcurrentPascal}, Mesa~\cite{Mesa}, Modula~\cite{Modula-2}, Turing~\cite{Turing:old}, Modula-3~\cite{Modula-3}, NeWS~\cite{NeWS}, Emerald~\cite{Emerald}, \uC~\cite{Buhr92a} and Java~\cite{Java}---provide monitors as explicit language constructs. In addition, operating-system kernels and device drivers have a monitor-like structure, although they often use lower-level primitives such as semaphores or locks to simulate monitors. For these reasons, this project proposes monitors as the core concurrency-construct.
 …
+        }
 \end{cfacode}
 The multi-acquisition monitor lock allows a monitor lock to be acquired by both \code{bar} or \code{baz} and acquired again in \code{foo}. In the calls to \code{bar} and \code{baz} the monitors are acquired in opposite order.
+The multi-acquisition monitor lock allows a monitor lock to be acquired by both \code{bar} or \code{baz} and acquired again in \code{foo}. In the calls to \code{bar} and \code{baz} the monitors are acquired in opposite order.
 However, such use leads the lock acquiring order problem. In the example above, the user uses implicit ordering in the case of function \code{foo} but explicit ordering in the case of \code{bar} and \code{baz}. This subtle mistake means that calling these routines concurrently may lead to deadlock and is therefore undefined behavior. As shown on several occasion\cit, solving this problem requires:
 …
 \end{tabular}
 \end{center}
 Notice how the counter is used without any explicit synchronisation and yet supports thread-safe semantics for both reading and writting.
+Notice how the counter is used without any explicit synchronisation and yet supports thread-safe semantics for both reading and writting.
 % ======================================================================
 …
 Depending on the choice of semantics for when monitor locks are acquired, interaction between monitors and \CFA's concept of polymorphism can be complex to support. However, it is shown that entry-point locking solves most of the issues.
 First of all, interaction between \code{otype} polymorphism and monitors is impossible since monitors do not support copying. Therefore, the main question is how to support \code{dtype} polymorphism. Since a monitor's main purpose is to ensure mutual exclusion when accessing shared data, this implies that mutual exclusion is only required for routines that do in fact access shared data. However, since \code{dtype} polymorphism always handles incomplete types (by definition), no \code{dtype} polymorphic routine can access shared data since the data requires knowledge about the type. Therefore, the only concern when combining \code{dtype} polymorphism and monitors is to protect access to routines.
 Before looking into complex control-flow, it is important to present the difference between the two acquiring options : callsite and entry-point locking, i.e. acquiring the monitors before making a mutex routine call or as the first operation of the mutex routine-call. For example:
+First of all, interaction between \code{otype} polymorphism and monitors is impossible since monitors do not support copying. Therefore, the main question is how to support \code{dtype} polymorphism. Since a monitor's main purpose is to ensure mutual exclusion when accessing shared data, this implies that mutual exclusion is only required for routines that do in fact access shared data. However, since \code{dtype} polymorphism always handles incomplete types (by definition), no \code{dtype} polymorphic routine can access shared data since the data requires knowledge about the type. Therefore, the only concern when combining \code{dtype} polymorphism and monitors is to protect access to routines.
+Before looking into complex control flow, it is important to present the difference between the two acquiring options : \gls{callsite-locking} and \gls{entry-point-locking}, i.e. acquiring the monitors before making a mutex routine call or as the first instruction of the mutex routine call. For example:
 \begin{center}
 \setlength\tabcolsep{1.5pt}
 …
 \end{center}
+\Gls{callsite-locking} is inefficient, since any \code{dtype} routine may have to obtain some lock before calling a routine, depending on whether or not the type passed is a monitor. However, with \gls{entry-point-locking} calling a monitor routine becomes exactly the same as calling it from anywhere else.
+Note the \code{mutex} keyword relies on the resolver, which means that in cases where a generic monitor routine is actually desired, writing a mutex routine is possible with the proper trait. This is possible because monitors are designed in terms a trait. For example:
+\Gls{callsite-locking} is inefficient, since any \code{dtype} routine may have to obtain some lock before calling a routine, depending on whether or not the type passed is a monitor. However, with \gls{entry-point-locking} calling a monitor routine becomes exactly the same as calling it from anywhere else. Note that the \code{mutex} keyword relies on the resolver rather than another form of language, which mean that in cases where a generic monitor routine is actually desired, writing a mutex routine is possible with the proper trait. This is possible because monitors are designed in terms a trait. For example:
 \begin{cfacode}
 //Incorrect
 //T is not a monitor
 forall(dtype T)
 void foo(T * mutex t);
+void foo(T * mutex t);
 //Correct
 //this function only works on monitors
+//this function only works on monitors
 //(any monitor)
 forall(dtype T | is_monitor(T))
 void bar(T * mutex t));
+void bar(T * mutex t));
 \end{cfacode}
 …
 In addition to mutual exclusion, the monitors at the core of \CFA's concurrency can also be used to achieve synchronisation. With monitors, this is generally achieved with internal or external scheduling as in\cit. Since internal scheduling of single monitors is mostly a solved problem, this proposal concentraits on extending internal scheduling to multiple monitors at once. Indeed, like the \gls{group-acquire} semantics, internal scheduling extends to multiple monitors at once in a way that is natural to the user but requires additional complexity on the implementation side.
 First, here is a simple example of such a technique:
+First, Here is a simple example of such a technique:
 \begin{cfacode}
 …
 \end{cfacode}
 There are two details to note here. First, there \code{signal} is a delayed operation, it only unblocks the waiting thread when it reaches the end of the critical section. This is needed to respect mutual-exclusion. Second, in \CFA, \code{condition} have no particular need to be stored inside a monitor, beyond any software engineering reasons. Here routine \code{foo} waits for the \code{signal} from \code{bar} before making further progress, effectively ensuring a basic ordering.
+There are two details to note here. First, there \code{signal} is a delayed operation, it only unblocks the waiting thread when it reaches the end of the critical section. This is needed to respect mutual-exclusion. Second, in \CFA, \code{condition} have no particular need to be stored inside a monitor, beyond any software engineering reasons. Here routine \code{foo} waits for the \code{signal} from \code{bar} before making further progress, effectively ensuring a basic ordering.
 An important aspect to take into account here is that \CFA does not allow barging, which means that once function \code{bar} releases the monitor, foo is guaranteed to resume immediately after (unless some other thread waited on the same condition). This guarantees offers the benefit of not having to loop arount waits in order to guarantee that a condition is still met. The main reason \CFA offers this guarantee is that users can easily introduce barging if it becomes a necessity but adding barging prevention or barging avoidance is more involved without language support. Supporting barging prevention as well as extending internal scheduling to multiple monitors is the main source of complexity in the design of \CFA concurrency.
 …
 \end{pseudo}
 \end{multicols}
+The example shows the simple case of having two threads (one for each column) and a single monitor A. One thread acquires before waiting (atomically blocking and releasing A) and the other acquires before signalling. There is an important thing to note here, both \code{wait} and \code{signal} must be called with the proper monitor(s) already acquired. This restriction is hidden on the user side in \uC, as it is a logical requirement for barging prevention.
+The previous example shows the simple case of having two threads (one for each column) and a single monitor A. One thread acquires before waiting (atomically blocking and releasing A) and the other acquires before signalling. There is an important thing to note here, both \code{wait} and \code{signal} must be called with the proper monitor(s) already acquired. This restriction is hidden on the user side in \uC, as it is a logical requirement for barging prevention.
 A direct extension of the previous example is the \gls{group-acquire} version:
 …
 \end{pseudo}
 \end{multicols}
 This version uses \gls{group-acquire} (denoted using the \& symbol), but the presence of multiple monitors does not add a particularly new meaning. Synchronization happens between the two threads in exactly the same way and order. The only difference is that mutual exclusion covers more monitors. On the implementation side, handling multiple monitors does add a degree of complexity as the next few examples demonstrate.
 …
 \end{center}
 It is particularly important to pay attention to code sections 8 and 3, which are where the existing semantics of internal scheduling need to be extended for multiple monitors. The root of the problem is that \gls{group-acquire} is used in a context where one of the monitors is already acquired and is why it is important to define the behaviour of the previous pseudo-code. When the signaller thread reaches the location where it should "release A \& B" (line 16), it must actually transfer ownership of monitor B to the waiting thread. This ownership trasnfer is required in order to prevent barging. Since the signalling thread still needs the monitor A, simply waking up the waiting thread is not an option because it would violate mutual exclusion. There are three options:
+It is particularly important to pay attention to code sections 8 and 3, which are where the existing semantics of internal scheduling need to be extended for multiple monitors. The root of the problem is that \gls{group-acquire} is used in a context where one of the monitors is already acquired and is why it is important to define the behaviour of the previous pseudo-code. When the signaller thread reaches the location where it should "release A \& B" (line 17), it must actually transfer ownership of monitor B to the waiting thread. This ownership trasnfer is required in order to prevent barging. Since the signalling thread still needs the monitor A, simply waking up the waiting thread is not an option because it would violate mutual exclusion. We are therefore left with three options:
 \subsubsection{Delaying signals}
 The first more obvious solution to solve the problem of multi-monitor scheduling is to keep ownership of all locks until the last lock is ready to be transferred. It can be argued that that moment is the correct time to transfer ownership when the last lock is no longer needed because this semantics fits most closely to the behaviour of single monitor scheduling. This solution has the main benefit of transferring ownership of groups of monitors, which simplifies the semantics from mutiple objects to a single group of object, effectively making the existing single monitor semantic viable by simply changing monitors to monitor collections.
+The first more obvious solution to solve the problem of multi-monitor scheduling is to keep ownership of all locks until the last lock is ready to be transferred. It can be argued that that moment is the correct time to transfer ownership when the last lock is no longer needed is what fits most closely to the behaviour of single monitor scheduling. This solution has the main benefit of transferring ownership of groups of monitors, which simplifies the semantics from mutiple objects to a single groupd of object. Effectively making the existing single monitor semantic viable by simply changing monitors to monitor collections.
 \begin{multicols}{2}
 Waiter
 …
 \end{pseudo}
 \end{multicols}
 However, this solution can become much more complicated depending on what is executed while secretly holding B (at line 10). Indeed, nothing prevents a user from signalling monitor A on a different condition variable:
+However, this solution can become much more complicated depending on what is executed while secretly holding B. Indeed, nothing prevents a user from signalling monitor A on a different condition variable:
 \newpage
 \begin{multicols}{2}
 …
 \end{multicols}
 The goal in this solution is to avoid the need to transfer ownership of a subset of the condition monitors. However, this goal is unreacheable in the previous example. Depending on the order of signals (line 12 and 15) two cases can happen.
 \paragraph{Case 1: thread 1 goes first.} In this case, the problem is that monitor A needs to be passed to thread 2 when thread 1 is done with it.
 \paragraph{Case 2: thread 2 goes first.} In this case, the problem is that monitor B needs to be passed to thread 1, which can be done directly or using thread 2 as an intermediate.
+The goal in this solution is to avoid the need to transfer ownership of a subset of the condition monitors. However, this goal is unreacheable in the previous example. Depending on the order of signals (line 12 and 15) two cases can happen. Note that ordering is not determined by a race condition but by whether signalled threads are enqueued in FIFO or FILO order. However, regardless of the answer, users can move line 15 before line 11 and get the reverse effect.
+\paragraph{Case 1: thread 1 will go first.} In this case, the problem is that monitor A needs to be passed to thread 2 when thread 1 is done with it.
+\paragraph{Case 2: thread 2 will go first.} In this case, the problem is that monitor B needs to be passed to thread 1. This can be done directly or using thread 2 as an intermediate.
 \\
-Note that ordering is not determined by a race condition but by whether signalled threads are enqueued in FIFO or FILO order. However, regardless of the answer, users can move line 15 before line 11 and get the reverse effect.
 In both cases however, the threads need to be able to distinguish on a per monitor basis which ones need to be released and which ones need to be transferred. Which means monitors cannot be handled as a single homogenous group.
 \subsubsection{Dependency graphs}
 In the Listing 1 pseudo-code, there is a solution which statisfies both barging prevention and mutual exclusion. If ownership of both monitors is transferred to the waiter when the signaller releases A and then the waiter transfers back ownership of A when it releases it then the problem is solved. Dynamically finding the correct order is therefore the second possible solution. The problem it encounters is that it effectively boils down to resolving a dependency graph of ownership requirements. Here even the simplest of code snippets requires two transfers and it seems to increase in a manner closer to polynomial. For example, the following code, which is just a direct extension to three monitors, requires at least three ownership transfer and has multiple solutions:
+In the Listing 1 pseudo-code, there is a solution which would statisfy both barging prevention and mutual exclusion. If ownership of both monitors is transferred to the waiter when the signaller releases A and then the waiter transfers back ownership of A when it releases it then the problem is solved. Dynamically finding the correct order is therefore the second possible solution. The problem it encounters is that it effectively boils down to resolving a dependency graph of ownership requirements. Here even the simplest of code snippets requires two transfers and it seems to increase in a manner closer to polynomial. For example the following code which is just a direct extension to three monitors requires at least three ownership transfer and has multiple solutions:
 \begin{multicols}{2}
 …
 \subsubsection{Partial signalling}
 Finally, the solution that is chosen for \CFA is to use partial signalling. Consider the following case:
+Finally, the solution that was chosen for \CFA is to use partial signalling. Consider the following case:
 \begin{multicols}{2}
 …
 \end{pseudo}
 \end{multicols}
+The partial signalling solution transfers ownership of monitor B at lines 10 but does not wake the waiting thread since it is still using monitor A. Only when it reaches line 11 does it actually wakeup the waiting thread. This solution has the benefit that complexity is encapsulated into only two actions, passing monitors to the next owner when they should be release and conditionnaly waking threads if all conditions are met. Contrary to the other solutions, this solution quickly hits an upper bound on complexity of implementation.
+The partial signalling solution transfers ownership of monitor B at lines 10 but does not wake the waiting thread since it is still using monitor A. Only when it reaches line 11 does it actually wakeup the waiting thread. This solution has the benefit that complexity is encapsulated in to only two actions, passing monitors to the next owner when they should be release and conditionnaly waking threads if all conditions are met. Contrary to the other solutions, this solution quickly hits an upper bound on complexity of implementation.
 % ======================================================================
 …
 % ======================================================================
 % ======================================================================
 An important note is that, until now, signalling a monitor was a delayed operation. The ownership of the monitor is transferred only when the monitor would have otherwise been released, not at the point of the \code{signal} statement. However, in some cases, it may be more convenient for users to immediately transfer ownership to the thread that is waiting for cooperation, which is achieved using the \code{signal_block} routine\footnote{name to be discussed}.
+An important note is that, until now, signalling a monitor was a delayed operation. The ownership of the monitor is transferred only when the monitor would have otherwise been released, not at the point of the \code{signal} statement. However, in some cases, it may be more convenient for users to immediately transfer ownership to the thread that is waiting for cooperation. This is achieved using the \code{signal_block} routine\footnote{name to be discussed}.
 For example here is an example highlighting the difference in behaviour:
 …
         bool inUse;
 public:
         void P() {
                 if(inUse) wait(c);
+        void P() {
+                if(inUse) wait(c);
                 inUse = true;
+        }
         void V() {
                 inUse = false;
                 signal(c);
+        void V() {
+                inUse = false;
+                signal(c);
+        }
+}
 …
         bool inUse;
 public:
         void P() {
                 if(inUse) _Accept(V);
+        void P() {
+                if(inUse) _Accept(V);
                 inUse = true;
+        }
         void g() {
+        void g() {
                 inUse = false;

doc/proposals/concurrency/version

r0720e049	r3d4b23fa
1		0.9.122
	1	0.9.119

doc/proposals/virtual.txt

-              r0720e049
+              r3d4b23fa
 Proposal for virtual functionality
-There are two types of virtual inheritance in this proposal, relaxed
-(implicit) and strict (explicit). Relaxed is the simpler case that uses the
-existing trait system with the addition of trait references and vtables.
-Strict adds some constraints and requires some additional notation but allows
-for down-casting.
-Relaxed Virtual Inheritance:
 Imagine the following code :
 …
 void draw(line*);
 While all the members of this simple UI support drawing, creating a UI that
 easily supports both these UI requires some tedious boiler-plate code:
+While all the members of this simple UI support drawing creating a UI that easily
+supports both these UI requires some tedious boiler-plate code :
 enum type_t { text, line };
 …
+}
+While this code will work as implemented, adding any new widgets or any new
+widget behaviors requires changing existing code to add the desired
+functionality. To ease this maintenance effort required CFA introduces the
+concept of trait references.
+While this code will work as indented, adding any new widgets or any new widget behaviors
+requires changing existing code to add the desired functionality. To ease this maintenance
+effort required CFA introduces the concept of dynamic types, in a manner similar to C++.
 Using trait references to implement the above gives the following :
+A simple usage of dynamic type with the previous example would look like :
 trait drawable objects[10];
+drawable* objects[10];
 fill_objects(objects);
 while(running) {
       for(drawable object : objects) {
+      for(drawable* object : objects) {
             draw(object);
+      }
+}
+The keyword trait is optional (by the same rules as the struct keyword). This
+is not currently supported in CFA and the lookup is not possible to implement
+statically. Therefore we need to add a new feature to handle having dynamic
 lookups like this.
+However, this is not currently do-able in the current CFA and furthermore is not
+possible to implement statically. Therefore we need to add a new feature to handle
+having dynamic types like this (That is types that are found dynamically not types
+that change dynamically).
+What we really want to do is express the fact that calling draw() on a trait
+reference should find the underlying type of the given parameter and find how
+it implements the routine, as in the example with the enumeration and union.
+C++ uses inheritance and virtual functions to find the
+desired type dynamically. CFA takes inspiration from this solution.
+For instance specifying that the drawable trait reference looks up the type
+of the first argument to find the implementation would be :
+What we really want to do is express the fact that calling draw() on a object
+should find the dynamic type of the parameter before calling the routine, much like the
+hand written example given above. We can express this by adding the virtual keyword on
+the parameter of the constraints on our trait:
 trait drawable(otype T) {
 …
 };
 This could be implied in simple cases like this one (single parameter on the
+trait and single generic parameter on the function). In more complex cases it
+would have to be explicitly given, or a strong convention would have to be
+enforced (e.g. implementation of trait functions is always drawn from the
 first polymorphic parameter).
+This expresses the idea that drawable is similar to an abstract base class in C++ and
+also gives meaning to trying to take a pointer of drawable. That is anything that can
+be cast to a drawable pointer has the necessary information to call the draw routine on
+that type. Before that drawable was only a abstract type while now it also points to a
+piece of storage which specify which behavior the object will have at run time.
+Once a function in a trait has been marked as virtual it defines a new
+function that takes in that trait's reference and then dynamically calls the
+underlying type implementation. Hence a trait reference becomes a kind of
+abstract type, cannot be directly instantiated but can still be used.
+This storage needs to be allocate somewhere. C++ just adds an invisible pointer at
+the beginning of the struct but we can do something more explicit for users, actually
+have a visible special field :
+One of the limitations of this design is that it does not support double
+dispatching, which concretely means traits cannot have routines with more than
+one virtual parameter. The program must have a single table to look up the
+function on. Using trait references with traits with more than one parameter
+is also restricted, initially forbidden, see extension.
+struct text {
+      char* text;
+      vtable drawable;
+};
+Extension: Multi-parameter Virtual Traits:
+struct line{
+      vtable drawable;
+      vec2 start;
+      vec2 end;
+};
+This implementation can be extended to traits with multiple parameters if
+one is called out as being the virtual trait. For example :
+With these semantics, adding a "vtable drawable" means that text pointers and line pointers are now
+convertible to drawable pointers. This conversion will not necessarily be a type only change however, indeed,
+the drawable pointer will point to the field "vtable drawable" not the head of the struct. However, since all
+the types are known at compile time, converting pointers becomes a simple offset operations.
+trait iterator(otype T, dtype Item) {
+        Maybe(Item) next(virtual T *);
+The vtable field contains a pointer to a vtable which contains all the information needed for the caller
+to find the function pointer of the desired behavior.
+One of the limitations of this design is that it does not support double dispatching, which
+concretely means traits cannot have routines with more than one virtual parameter. This design
+would have many ambiguities if it did support multiple virtual parameter. A futher limitation is
+that traits over more than one type cannot have vtables meaningfully defined for them, as the
+particular vtable to use would be a function of the other type(s) the trait is defined over.
+It is worth noting that the function pointers in these vtables are bound at object construction, rather than
+function call-site, as in Cforall's existing polymorphic functions. As such, it is possible that two objects
+with the same static type would have a different vtable (consider what happens if draw(line*) is overridden
+between the definitions of two line objects). Given that the virtual drawable* erases static types though,
+this should not be confusing in practice. A more distressing possibility is that of creating an object that
+outlives the scope of one of the functions in its vtable. This is certainly a possible bug, but it is of a
+type that C programmers are familiar with, and should be able to avoid by the usual methods.
+Extensibility.
+One of the obvious critics of this implementation is that it lacks extensibility for classes
+that cannot be modified (ex: Linux C headers). However this solution can be extended to
+allow more extensibility by adding "Fat pointers".
+Indeed, users could already "solve" this issue by writing their own fat pointers as such:
+trait MyContext(otype T) {
+      void* get_stack(virtual T*)
+};
+void* get_stack(ucontext_t *context);
+struct fat_ucontext_t {
+      vtable MyContext;
+      ucontext_t *context;
+}
+iterator(int) generators[10];
+Which creates a collection of iterators that produce integers, regardless of
+how those iterators are implemented. This may require a note that this trait
+is virtual on T and not Item, but noting it on the functions may be enough.
+Strict Virtual Inheritance:
+One powerful feature relaxed virtual does not support is the idea of down
+casting. Once something has been converted into a trait reference there is
+very little we can do to recover and of the type information, only the trait's
+required function implementations are kept.
+To allow down casting strict virtual requires that all traits and structures
+involved be organized into a tree. Each trait or struct must have a unique
+position on this tree (no multiple inheritance).
+This is declared as follows :
+trait error(otype T) virtual {
+        const char * msg(T *);
+//Tedious forwarding routine
+void* get_stack(fat_ucontext_t *ptr) {
+      return get_stack(ptr->context);
+}
+trait io_error(otype T) virtual error {
+        FILE * src(T *);
+}
+However, users would have to write all the virtual methods they want to override and make
+them all simply forward to the existing method that takes the corresponding POCO(Plain Old C Object).
+struct eof_error virtual io_error {
+        FILE * fd;
+The alternative we propose is to use language level fat pointers :
+trait MyContext(otype T) {
+      void* get_stack(virtual T*)
 };
+So the trait error is the head of a new tree and io_error is a child of it.
+void* get_stack(ucontext_t *context);
+Also the parent trait is implicitly part of the assertions of the children,
+so all children implement the same operations as the parent. By the unique
+path down the tree, we can also uniquely order them so that a prefix of a
+child's vtable has the same format as its parent's.
+//The type vptr(ucontext_t) all
+vptr(ucontext_t) context;
+This gives us an important extra feature, runtime checking of the parent-child
+relationship with a C++ dynamic_cast like operation. Allowing checked
+conversions from trait references to more particular references, which works
+if the underlying type is, or is a child of, the new trait type.
+These behave exactly as the previous example but all the forwarding routines are automatically generated.
+Extension: Multiple Parents
+Bikeshedding.
+Although each trait/struct must have a unique position on each tree, it could
+have positions on multiple trees. All this requires is the ability to give
+multiple parents, as here :
+It may be desirable to add fewer new keywords than discussed in this proposal; it is possible that "virtual"
+could replace both "vtable" and "vptr" above with unambiguous contextual meaning. However, for purposes of
+clarity in the design discussion it is beneficial to keep the keywords for separate concepts distinct.
-trait region(otype T) virtual drawable, collider;
-The restriction being, the parents must come from different trees. This
-object (and all of its children) can be cast to either tree. This is handled
-by generating a separate vtable for each tree the structure is in.
-Extension: Multi-parameter Strict Virtual
-If a trait has multiple parameters then one must be called out to be the one
-we generate separate vtables for, as in :
-trait example(otype T, otype U) virtual(T) ...
-This can generate a separate vtable for each U for which all the T+U
-implementations are provided. These are then separate nodes in the tree (or
-the root of different trees) as if each was created individually. Providing a
-single unique instance of these nodes would be the most difficult aspect of
-this extension, possibly intractable, though with sufficient hoisting and
-link-once duplication it may be possible.
-Example:
-trait argument(otype T) virtual {
-        char short_name(virtual T *);
-        bool is_set(virtual T *);
-};
-trait value_argument(otype T, otype U) virtual(T) argument {
-        U get_value(virtual T *);
-};
-Extension: Structural Inheritance
-Currently traits must be the internal nodes and structs the leaf nodes.
-Structs could be made internal nodes as well, in which case the child structs
-would likely structurally inherit the fields of their parents.
-Storing the Virtual Lookup Table (vtable):
-We have so far been silent on how the vtable is created, stored and accessed.
-Creation happens at compile time. Function pointers are found by using the
-same best match rules as elsewhere (additional rules for defaults from the
-parent may or may not be required). For strict virtual this must happen at the
-global scope and forbidding static functions, to ensure that a single unique
-vtable is created. Similarly, there may have to be stricter matching rules
-for the functions that go into the vtable, possibly requiring an exact match.
-Relaxed virtual could relax both restrictions, if we allow different vtable
-at different conversion (struct to trait reference) sites. If it is allowed
-local functions being bound to a vtable could cause issues when they go out
-of scope, however this should follow the lifetime rules most C programs
-already follow implicitly.
-Most vtables should be stored statically, the only exception being some of
-the relaxed vtables that could have local function pointers. These may be able
-to be stack allocated. All vtables should be immutable and require no manual
-cleanup.
-Access has two main options:
-The first is through the use of fat pointers, or a tuple of pointers. When the
-object is converted to a trait reference, the pointers to its vtables are
-stored along side it.
-This allows for compatibility with existing structures (such as those imported
-from C) and is the default storage method unless a different one is given.
-The other is by inlining the vtable pointer as "intrusive vtables". This adds
-a field to the structure to the vtable. The trait reference then has a single
-pointer to this field, the vtable includes an offset to find the beginning of
-the structure again.
-This is used if you specify a vtable field in the structure. If given in the
-trait the vtable pointer in the trait reference can then become a single
-pointer to the vtable field and use that to recover the original object
-pointer as well as retrieve all operations.
-trait drawable(otype T) {
-        vtable drawable;
-};
-struct line {
-        vtable drawable;
-        vec2 start;
-        vec2 end;
-};
-This inline code allows trait references to be converted to plain pointers
-(although they still must be called specially). The vtable field may just be
-an opaque block of memory or it may allow user access to the vtable. If so
-then there should be some way to retrieve the type of the vtable, which will be
-autogenerated and often unique.
-Keyword Usage:
-It may be desirable to add fewer new keywords than discussed in this proposal.
-It is possible that "virtual" could replace both "vtable" above with
-unambiguous contextual meaning. However, for purposes of clarity in the design
-discussion it is beneficial to keep the keywords for separate concepts distinct.
-Trait References and Operations:
-sizeof(drawable) will return the size of the trait object itself. However :
-line a_line;
-drawable widget = a_line;
-sizeof(widget);
-Will instead return the sizeof the underlying object, although the trait must
-require that its implementation is sized for there to be a meaningful value
-to return. You may also get the size of the trait reference with
-sizeof(&widget);
-Calling free on a trait reference will free the memory for the object. It will
-leave the vtables alone, as those are (always?) statically allocated.

doc/refrat/Makefile

r0720e049	r3d4b23fa
9	9	SOURCES = ${addsuffix .tex, \
10	10	refrat \
11		~~keywords \~~
12		~~operidents \~~
13	11	}
14	12

doc/refrat/refrat.tex

-              r0720e049
+              r3d4b23fa
 %% Created On       : Wed Apr  6 14:52:25 2016
 %% Last Modified By : Peter A. Buhr
 %% Last Modified On : Sun Aug  6 10:25:31 2017
 %% Update Count     : 105
+%% Last Modified On : Fri Jun  2 10:43:14 2017
+%% Update Count     : 83
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 % requires tex packages: texlive-base texlive-latex-base tex-common texlive-humanities texlive-latex-extra texlive-fonts-recommended
 \documentclass[openright,twoside,11pt]{report}
+\documentclass[openright,twoside]{report}
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 …
 \usepackage{mathptmx}                                   % better math font with "times"
 \usepackage[usenames]{color}
+\input{common}                                          % common CFA document macros
+\usepackage[pagewise]{lineno}
+\renewcommand{\linenumberfont}{\scriptsize\sffamily}
+\input{common}                                          % bespoke macros used in the document
 \usepackage[dvips,plainpages=false,pdfpagelabels,pdfpagemode=UseNone,colorlinks=true,pagebackref=true,linkcolor=blue,citecolor=blue,urlcolor=blue,pagebackref=true,breaklinks=true]{hyperref}
 \usepackage{breakurl}
 \renewcommand{\UrlFont}{\small\sf}
-\usepackage[pagewise]{lineno}
-\renewcommand{\linenumberfont}{\scriptsize\sffamily}
-\usepackage[firstpage]{draftwatermark}
-\SetWatermarkLightness{0.9}
-% Default underscore is too low and wide. Cannot use lstlisting "literate" as replacing underscore
-% removes it as a variable-name character so keywords in variables are highlighted. MUST APPEAR
-% AFTER HYPERREF.
-\renewcommand{\textunderscore}{\leavevmode\makebox[1.2ex][c]{\rule{1ex}{0.075ex}}}
 \setlength{\topmargin}{-0.45in}                                                 % move running title into header
 \setlength{\headsep}{0.25in}
 …
 \CFAStyle                                                                                               % use default CFA format-style
-\lstnewenvironment{C++}[1][]                            % use C++ style
-{\lstset{language=C++,moredelim=**[is][\protect\color{red}]{®}{®}#1}}
-{}
 % inline code ©...© (copyright symbol) emacs: C-q M-)
 …
 \date{
 \today
+DRAFT \\ \today
 }% date
 …
 \clearpage
-\thispagestyle{plain}
 \pdfbookmark[1]{Contents}{section}
 \tableofcontents
 \clearpage
-\thispagestyle{plain}
 \pagenumbering{arabic}
 …
 \begin{syntax}
+\lhs{keyword} one of
+\rhs \dots
+\rhs \input{keywords}
+\oldlhs{keyword}
+\rhs ©forall©
+\rhs ©lvalue©
+\rhs ©trait©
+\rhs ©dtype©
+\rhs ©ftype©
+\rhs ©otype©
 \end{syntax}
 …
 \begin{table}[hbt]
+\centering
+\input{operidents}
+\hfil
+\begin{tabular}[t]{ll}
+%identifier & operation \\ \hline
+©?[?]© & subscripting \impl{?[?]}\\
+©?()© & function call \impl{?()}\\
+©?++© & postfix increment \impl{?++}\\
+©?--© & postfix decrement \impl{?--}\\
+©++?© & prefix increment \impl{++?}\\
+©--?© & prefix decrement \impl{--?}\\
+©*?© & dereference \impl{*?}\\
+©+?© & unary plus \impl{+?}\\
+©-?© & arithmetic negation \impl{-?}\\
+©~?© & bitwise negation \impl{~?}\\
+©!?© & logical complement \impl{"!?}\\
+©?*?© & multiplication \impl{?*?}\\
+©?/?© & division \impl{?/?}\\
+\end{tabular}\hfil
+\begin{tabular}[t]{ll}
+%identifier & operation \\ \hline
+©?%?© & remainder \impl{?%?}\\
+©?+?© & addition \impl{?+?}\\
+©?-?© & subtraction \impl{?-?}\\
+©?<<?© & left shift \impl{?<<?}\\
+©?>>?© & right shift \impl{?>>?}\\
+©?<?© & less than \impl{?<?}\\
+©?<=?© & less than or equal \impl{?<=?}\\
+©?>=?© & greater than or equal \impl{?>=?}\\
+©?>?© & greater than \impl{?>?}\\
+©?==?© & equality \impl{?==?}\\
+©?!=?© & inequality \impl{?"!=?}\\
+©?&?© & bitwise AND \impl{?&?}\\
+\end{tabular}\hfil
+\begin{tabular}[t]{ll}
+%identifier & operation \\ \hline
+©?^?© & exclusive OR \impl{?^?}\\
+©?|?© & inclusive OR \impl{?"|?}\\
+©?=?© & simple assignment \impl{?=?}\\
+©?*=?© & multiplication assignment \impl{?*=?}\\
+©?/=?© & division assignment \impl{?/=?}\\
+©?%=?© & remainder assignment \impl{?%=?}\\
+©?+=?© & addition assignment \impl{?+=?}\\
+©?-=?© & subtraction assignment \impl{?-=?}\\
+©?<<=?© & left-shift assignment \impl{?<<=?}\\
+©?>>=?© & right-shift assignment \impl{?>>=?}\\
+©?&=?© & bitwise AND assignment \impl{?&=?}\\
+©?^=?© & exclusive OR assignment \impl{?^=?}\\
+©?|=?© & inclusive OR assignment \impl{?"|=?}\\
+\end{tabular}
+\hfil
 \caption{Operator Identifiers}
 \label{opids}

doc/rob_thesis/Makefile

-              r0720e049
+              r3d4b23fa
+TeXLIB = .:../LaTeXmacros:../bibliography/:
+## Define the appropriate configuration variables.
+TeXLIB = .:../LaTeXmacros:../LaTeXmacros/listings:../LaTeXmacros/enumitem:../bibliography/:
 LaTeX  = TEXINPUTS=${TeXLIB} && export TEXINPUTS && pdflatex -halt-on-error
 BibTeX = BIBINPUTS=${TeXLIB} && export BIBINPUTS && bibtex
+all : thesis.pdf
+## Define the text source files.
+thesis.pdf : Makefile ../LaTeXmacros/common.tex cfa-format.tex thesis.tex intro.tex ctordtor.tex tuples.tex variadic.tex conclusions.tex
+        ${LaTeX} thesis
+        ${BibTeX} thesis
+        ${LaTeX} thesis
+        ${LaTeX} thesis
+        pdf2ps thesis.pdf thesis.ps
+# SOURCES = ${addsuffix .tex, \
+# thesis \
+# }
+clean :
+# FIGURES = ${addsuffix .tex, \
+# }
+# PICTURES = ${addsuffix .pstex, \
+# }
+# PROGRAMS = ${addsuffix .tex, \
+# }
+# GRAPHS = ${addsuffix .tex, \
+# }
+# ## Define the documents that need to be made.
+# DOCUMENT = thesis.pdf
+# Directives #
+# all : ${DOCUMENT}
+# clean :
+#       rm -f *.bbl *.aux *.dvi *.idx *.ilg *.ind *.brf *.out *.log *.toc *.blg *.pstex_t *.cf \
+#               ${FIGURES} ${PICTURES} ${PROGRAMS} ${GRAPHS} ${basename ${DOCUMENT}}.ps ${DOCUMENT}
+# File Dependencies #
+# ${DOCUMENT} : ${basename ${DOCUMENT}}.ps
+#       ps2pdf $<
+# ${basename ${DOCUMENT}}.ps : ${basename ${DOCUMENT}}.dvi
+#       dvips $< -o $@
+# ${basename ${DOCUMENT}}.dvi : Makefile ${GRAPHS} ${PROGRAMS} ${PICTURES} ${FIGURES} ${SOURCES} ${basename ${DOCUMENT}}.tex \
+#               ../LaTeXmacros/common.tex ../LaTeXmacros/indexstyle ../bibliography/cfa.bib
+#       # Conditionally create an empty *.ind (index) file for inclusion until makeindex is run.
+#       if [ ! -r ${basename $@}.ind ] ; then touch ${basename $@}.ind ; fi
+#       # Must have *.aux file containing citations for bibtex
+#       if [ ! -r ${basename $@}.aux ] ; then ${LaTeX} ${basename $@}.tex ; fi
+#       -${BibTeX} ${basename $@}
+#       # Some citations reference others so run steps again to resolve these citations
+#       ${LaTeX} ${basename $@}.tex
+#       -${BibTeX} ${basename $@}
+#       # Make index from *.aux entries and input index at end of document
+#       makeindex -s ../LaTeXmacros/indexstyle ${basename $@}.idx
+#       ${LaTeX} ${basename $@}.tex
+#       # Run again to get index title into table of contents
+#       ${LaTeX} ${basename $@}.tex
+# predefined :
+#       sed -f predefined.sed ${basename ${DOCUMENT}}.tex > ${basename $@}.cf
+# ## Define the default recipes.
+# %.tex : %.fig
+#       fig2dev -L eepic $< > $@
+# %.ps : %.fig
+#       fig2dev -L ps $< > $@
+# %.pstex : %.fig
+#       fig2dev -L pstex $< > $@
+#       fig2dev -L pstex_t -p $@ $< > $@_t
+all:
+        $(LaTeX) thesis
+        $(BibTeX) thesis
+        $(LaTeX) thesis
+        $(LaTeX) thesis
+clean:
         rm -f *.aux *.bbl *.blg *.lof *.log *.lot *.out *.toc
 spotless : clean
         rm -f thesis.pdf thesis.ps
+splotless: clean
+        rm -f thesis.pdf

doc/rob_thesis/thesis.tex

-              r0720e049
+              r3d4b23fa
     pdfpagelabels=true,     % adds page number as label in Acrobat's page count
     bookmarks=true,         % show bookmarks bar?
     unicode=false,          % non-Latin characters in Acrobat's bookmarks
     pdftoolbar=true,        % show Acrobat's toolbar?
     pdfmenubar=true,        % show Acrobat's menu?
+    unicode=false,          % non-Latin characters in Acrobat’s bookmarks
+    pdftoolbar=true,        % show Acrobat’s toolbar?
+    pdfmenubar=true,        % show Acrobat’s menu?
     pdffitwindow=false,     % window fit to page when opened
     pdfstartview={FitH},    % fits the width of the page to the window

doc/user/EHMHierarchy.fig

-              r0720e049
+              r3d4b23fa
 #FIG 3.2  Produced by xfig version 3.2.5c
+#FIG 3.2  Produced by xfig version 3.2.5b
 Landscape
 Center
 …
 1 0 1 0 7 100 0 -1 0.000 0 0 -1 1 0 2
 1 1.00 60.00 90.00
 1425 2925 1200
+1425 3000 1200
 1 0 1 0 7 100 0 -1 0.000 0 0 -1 1 0 2
 1 1.00 60.00 90.00
 …
 1 1.00 60.00 90.00
 1950 4950 1725
 1 0 50 -1 0 13 0.0000 2 135 225 1950 1650 IO\001
 1 0 50 -1 0 13 0.0000 2 135 915 4950 1650 Arithmetic\001
 1 0 50 -1 0 13 0.0000 2 150 330 1350 2100 File\001
 1 0 50 -1 0 13 0.0000 2 135 735 2550 2100 Network\001
 1 0 50 -1 0 13 0.0000 2 180 1215 3750 2100 DivideByZero\001
 1 0 50 -1 0 13 0.0000 2 150 810 4950 2100 Overflow\001
 1 0 50 -1 0 13 0.0000 2 150 915 6000 2100 Underflow\001
 1 0 50 -1 0 13 0.0000 2 180 855 3450 1200 Exception\001
+1 0 100 0 0 12 0.0000 0 135 195 1950 1650 IO\001
+1 0 100 0 0 12 0.0000 0 135 870 4950 1650 Arithmetic\001
+1 0 100 0 0 12 0.0000 0 135 315 1350 2100 File\001
+1 0 100 0 0 12 0.0000 0 135 690 2550 2100 Network\001
+1 0 100 0 0 12 0.0000 0 180 1170 3750 2100 DivideByZero\001
+1 0 100 0 0 12 0.0000 0 135 750 4950 2100 Overflow\001
+1 0 100 0 0 12 0.0000 0 135 855 6000 2100 Underflow\001
+1 0 100 0 0 12 0.0000 0 180 840 3450 1200 Exception\001

doc/user/Makefile

r0720e049	r3d4b23fa
9	9	SOURCES = ${addsuffix .tex, \
10	10	user \
11		~~../refrat/keywords \~~
12		~~../refrat/operidents \~~
13	11	}
14	12

doc/user/user.tex

-              r0720e049
+              r3d4b23fa
 %% Created On       : Wed Apr  6 14:53:29 2016
 %% Last Modified By : Peter A. Buhr
 %% Last Modified On : Sun Aug  6 10:24:21 2017
 %% Update Count     : 3036
+%% Last Modified On : Thu Jul 13 11:44:57 2017
+%% Update Count     : 2690
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 …
 \usepackage{mathptmx}                                   % better math font with "times"
 \usepackage[usenames]{color}
+\usepackage[pagewise]{lineno}
+\renewcommand{\linenumberfont}{\scriptsize\sffamily}
 \input{common}                                          % common CFA document macros
 \usepackage[dvips,plainpages=false,pdfpagelabels,pdfpagemode=UseNone,colorlinks=true,pagebackref=true,linkcolor=blue,citecolor=blue,urlcolor=blue,pagebackref=true,breaklinks=true]{hyperref}
 …
 \renewcommand{\UrlFont}{\small\sf}
-\usepackage[pagewise]{lineno}
-\renewcommand{\linenumberfont}{\scriptsize\sffamily}
-\usepackage[firstpage]{draftwatermark}
-\SetWatermarkLightness{0.9}
 % Default underscore is too low and wide. Cannot use lstlisting "literate" as replacing underscore
 % removes it as a variable-name character so keywords in variables are highlighted. MUST APPEAR
 % AFTER HYPERREF.
+\renewcommand{\_}{\leavevmode\makebox[1.2ex][c]{\rule{1ex}{0.075ex}}}
 \renewcommand{\textunderscore}{\leavevmode\makebox[1.2ex][c]{\rule{1ex}{0.075ex}}}
 …
 \CFAStyle                                                                                               % use default CFA format-style
+\lstnewenvironment{C++}[1][]                            % use C++ style
+\lstnewenvironment{C++}[1][]
 {\lstset{language=C++,moredelim=**[is][\protect\color{red}]{®}{®}#1}}
 {}
 …
 \newcommand{\B}[1]{{\Textbf[blue]{#1}}}
 \newcommand{\G}[1]{{\Textbf[OliveGreen]{#1}}}
-\newcommand{\KWC}{K-W C\xspace}
 \newsavebox{\LstBox}
 …
 \date{
 \today
+DRAFT \\ \today
 }% date
 …
 This document is a programmer reference-manual for the \CFA programming language.
 The manual covers the core features of the language and runtime-system, with simple examples illustrating syntax and semantics of each feature.
 The manual does not teach programming, \ie how to combine the new constructs to build complex programs.
+The manual does not teach programming, i.e., how to combine the new constructs to build complex programs.
 A reader should already have an intermediate knowledge of control flow, data structures, and concurrency issues to understand the ideas presented, as well as some experience programming in C/\CC.
 Implementers should refer to the \CFA Programming Language Specification for details about the language syntax and semantics.
 …
 \section{History}
 The \CFA project started with \Index*{Dave Till}\index{Till, Dave}'s \Index*{K-W C}~\cite{Buhr94a,Till89}, which extended C with new declaration syntax, multiple return values from routines, and advanced assignment capabilities using the notion of tuples.
+The \CFA project started with \Index*{K-W C}~\cite{Buhr94a,Till89}, which extended C with new declaration syntax, multiple return values from routines, and advanced assignment capabilities using the notion of tuples.
 (See~\cite{Werther96} for similar work in \Index*[C++]{\CC{}}.)
 The first \CFA implementation of these extensions was by \Index*{Rodolfo Esteves}\index{Esteves, Rodolfo}~\cite{Esteves04}.
 The signature feature of \CFA is \emph{\Index{overload}able} \Index{parametric-polymorphic} functions~\cite{forceone:impl,Cormack90,Duggan96} with functions generalized using a ©forall© clause (giving the language its name):
+The first \CFA implementation of these extensions was by Esteves~\cite{Esteves04}.
+The signature feature of \CFA is \Index{overload}able \Index{parametric-polymorphic} functions~\cite{forceone:impl,Cormack90,Duggan96} with functions generalized using a ©forall© clause (giving the language its name):
 \begin{lstlisting}
 ®forall( otype T )® T identity( T val ) { return val; }
 …
 \end{lstlisting}
 % extending the C type system with parametric polymorphism and overloading, as opposed to the \Index*[C++]{\CC{}} approach of object-oriented extensions.
 \CFA{}\hspace{1pt}'s polymorphism was originally formalized by \Index*{Glen Ditchfield}\index{Ditchfield, Glen}~\cite{Ditchfield92}, and first implemented by \Index*{Richard Bilson}\index{Bilson, Richard}~\cite{Bilson03}.
+\CFA{}\hspace{1pt}'s polymorphism was originally formalized by Ditchfiled~\cite{Ditchfield92}, and first implemented by Bilson~\cite{Bilson03}.
 However, at that time, there was little interesting in extending C, so work did not continue.
 As the saying goes, ``\Index*{What goes around, comes around.}'', and there is now renewed interest in the C programming language because of legacy code-bases, so the \CFA project has been restarted.
 …
 Language developers often state that adequate \Index{library support} takes more work than designing and implementing the language itself.
 Fortunately, \CFA, like \Index*[C++]{\CC{}}, starts with immediate access to all exiting C libraries, and in many cases, can easily wrap library routines with simpler and safer interfaces, at very low cost.
 Hence, \CFA begins by leveraging the large repository of C libraries, and than allows programmers to incrementally augment their C programs with modern \Index{backward-compatible} features.
+Hence, \CFA begins by leveraging the large repository of C libraries at little cost.
 \begin{comment}
 …
 \begin{cfa}
 char abs( char );
+®extern "C" {® int abs( int ); ®}®              §\C{// use default C routine for int}§
+®extern "C" {®
+int abs( int );                                                 §\C{// use default C routine for int}§
+®}® // extern "C"
 long int abs( long int );
 long long int abs( long long int );
 …
 Hence, there is the same need as in \CC, to know if a name is a C or \CFA name, so it can be correctly formed.
 There is no way around this problem, other than C's approach of creating unique names for each pairing of operation and type.
 This example strongly illustrates a core idea in \CFA: \emph{the \Index{power of a name}}.
 The name ``©abs©'' evokes the notion of absolute value, and many mathematical types provide the notion of absolute value.
 …
 \section[Compiling a CFA Program]{Compiling a \CFA Program}
 The command ©cfa© is used to compile a \CFA program and is based on the \Index{GNU} \Indexc{gcc} command, \eg:
 \begin{cfa}
 cfa§\indexc{cfa}\index{compilation!cfa@©cfa©}§ [ gcc-options ] [ C/§\CFA{}§ source-files ] [ assembler/loader files ]
+The command ©cfa© is used to compile \CFA program(s), and is based on the GNU \Indexc{gcc} command, \eg:
+\begin{cfa}
+cfa§\indexc{cfa}\index{compilation!cfa@©cfa©}§ [ gcc-options ] C/§\CFA{}§-files [ assembler/loader-files ]
 \end{cfa}
 \CFA programs having the following ©gcc© flags turned on:
 …
 The 1999 C standard plus GNU extensions.
 \item
+\Indexc[deletekeywords=inline]{-fgnu89-inline}\index{compilation option!-fgnu89-inline@{\lstinline[deletekeywords=inline]$-fgnu89-inline$}}
+{\lstset{deletekeywords={inline}}
+\Indexc{-fgnu89-inline}\index{compilation option!-fgnu89-inline@{©-fgnu89-inline©}}
 Use the traditional GNU semantics for inline routines in C99 mode, which allows inline routines in header files.
+}%
 \end{description}
 The following new \CFA options are available:
 …
 \Indexc{-CFA}\index{compilation option!-CFA@©-CFA©}
 Only the C preprocessor and the \CFA translator steps are performed and the transformed program is written to standard output, which makes it possible to examine the code generated by the \CFA translator.
 The generated code starts with the standard \CFA \Index{prelude}.
+The generated code started with the standard \CFA prelude.
 \item
 …
 \Indexc{-nodebug}\index{compilation option!-nodebug@©-nodebug©}
 The program is linked with the non-debugging version of the runtime system, so the execution of the program is faster.
 \Emph{However, no runtime checks or ©assert©s are performed so errors usually result in abnormal program behaviour or termination.}
+\Emph{However, no runtime checks or ©assert©s are performed so errors usually result in abnormal program termination.}
 \item
 …
 \textbf{This option is the default.}
-\begin{comment}
 \item
 \Indexc{-no-include-stdhdr}\index{compilation option!-no-include-stdhdr@©-no-include-stdhdr©}
 Do not supply ©extern "C"© wrappers for \Celeven standard include files (see~\VRef{s:StandardHeaders}).
 \textbf{This option is \emph{not} the default.}
-\end{comment}
 \end{description}
 …
 \item
 \Indexc{__CFA__}\index{preprocessor variables!__CFA__@©__CFA__©},
 \Indexc{__CFORALL__}\index{preprocessor variables!__CFORALL__@©__CFORALL__©}, and
+\Indexc{__CFORALL__}\index{preprocessor variables!__CFORALL__@©__CFORALL__©} and
 \Indexc{__cforall}\index{preprocessor variables!__cforall@©__cforall©}
 are always available during preprocessing and have no value.
 …
 \label{s:BackquoteIdentifiers}
 \CFA introduces several new keywords (see \VRef{s:CFAKeywords}) that can clash with existing C variable-names in legacy code.
+\CFA introduces in new keywords (see \VRef{s:CFAKeywords}) that can clash with existing C variable-names in legacy code.
 Keyword clashes are accommodated by syntactic transformations using the \CFA backquote escape-mechanism:
 \begin{cfa}
 …
 double ®`®forall®`® = 3.5;
 \end{cfa}
 Existing C programs with keyword clashes can be converted by enclosing keyword identifiers in backquotes, and eventually the identifier name can be changed to a non-keyword name.
+\VRef[Figure]{f:HeaderFileInterposition} shows how clashes in existing C header-files (see~\VRef{s:StandardHeaders}) can be handled using preprocessor \newterm{interposition}: ©#include_next© and ©-I filename©.
+Several common C header-files with keyword clashes are fixed in the standard \CFA header-library, so there is a seamless programming-experience.
+\VRef[Figure]{f:InterpositionHeaderFile} shows how clashes in C header files (see~\VRef{s:StandardHeaders}) can be handled using preprocessor \newterm{interposition}: ©#include_next© and ©-I filename©:
 \begin{figure}
 \begin{cfa}
 // include file uses the CFA keyword "with".
 #if ! defined( with )                   §\C{// nesting ?}§
 #define with ®`®with®`®                 §\C{// make keyword an identifier}§
+// include file uses the CFA keyword "otype".
+#if ! defined( otype )                  §\C{// nesting ?}§
+#define otype ®`®otype®`®               §\C{// make keyword an identifier}§
 #define __CFA_BFD_H__
 #endif
 ®#include_next <bfdlink.h>              §\C{// must have internal check for multiple expansion}§
+®
 #if defined( with ) && defined( __CFA_BFD_H__ ) §\C{// reset only if set}§
 #undef with
+#endif // ! otype
+#®include_next® <bfd.h>                 §\C{// must have internal check for multiple expansion}§
+#if defined( otype ) && defined( __CFA_BFD_H__ )        §\C{// reset only if set}§
+#undef otype
 #undef __CFA_BFD_H__
 #endif
 \end{cfa}
 \caption{Header-File Interposition}
 \label{f:HeaderFileInterposition}
+#endif // otype && __CFA_BFD_H__
+\end{cfa}
+\caption{Interposition of Header File}
+\label{f:InterpositionHeaderFile}
 \end{figure}
 …
 While C provides ©continue© and ©break© statements for altering control flow, both are restricted to one level of nesting for a particular control structure.
 Unfortunately, this restriction forces programmers to use \Indexc{goto} to achieve the equivalent control-flow for more than one level of nesting.
 To prevent having to switch to the ©goto©, \CFA extends the \Indexc{continue}\index{continue@\lstinline $continue$!labelled}\index{labelled!continue@©continue©} and \Indexc{break}\index{break@\lstinline $break$!labelled}\index{labelled!break@©break©} with a target label to support static multi-level exit\index{multi-level exit}\index{static multi-level exit}~\cite{Buhr85}, as in Java.
+To prevent having to switch to the ©goto©, \CFA extends the \Indexc{continue}\index{continue@\lstinline $continue$!labelled}\index{labelled!continue@©continue©} and \Indexc{break}\index{break@\lstinline $break$!labelled}\index{labelled!break@©break©} with a target label to support static multi-level exit\index{multi-level exit}\index{static multi-level exit}~\cite{Buhr85}.
 For both ©continue© and ©break©, the target label must be directly associated with a ©for©, ©while© or ©do© statement;
 for ©break©, the target label can also be associated with a ©switch©, ©if© or compound (©{}©) statement.
+\VRef[Figure]{f:MultiLevelExit} shows ©continue© and ©break© indicating the specific control structure, and the corresponding C program using only ©goto© and labels.
+The innermost loop has 7 exit points, which cause continuation or termination of one or more of the 7 \Index{nested control-structure}s.
+\VRef[Figure]{f:MultiLevelResumeTermination} shows the labelled ©continue© and ©break©, specifying which control structure is the target for exit, and the corresponding C program using only ©goto©.
+The innermost loop has 7 exit points, which cause resumption or termination of one or more of the 7 \Index{nested control-structure}s.
+Java supports both labelled ©continue© and ©break© statements.
 \begin{figure}
 \begin{tabular}{@{\hspace{\parindentlnth}}l@{\hspace{\parindentlnth}}l@{\hspace{\parindentlnth}}l@{}}
 \multicolumn{1}{@{\hspace{\parindentlnth}}c@{\hspace{\parindentlnth}}}{\textbf{\CFA}}   & \multicolumn{1}{@{\hspace{\parindentlnth}}c}{\textbf{C}}      \\
+\begin{tabular}{@{\hspace{\parindentlnth}}l@{\hspace{1.5em}}l@{}}
+\multicolumn{1}{c@{\hspace{1.5em}}}{\textbf{\CFA}}      & \multicolumn{1}{c}{\textbf{C}}        \\
 \begin{cfa}
 ®LC:® {
 …
                         ®LF:® for ( ... ) {
                                 ®LW:® while ( ... ) {
                                         ... break ®LC®; ...
                                         ... break ®LS®; ...
                                         ... break ®LIF®; ...
                                         ... continue ®LF;® ...
                                         ... break ®LF®; ...
                                         ... continue ®LW®; ...
                                         ... break ®LW®; ...
+                                        ... break ®LC®; ...                     // terminate compound
+                                        ... break ®LS®; ...                     // terminate switch
+                                        ... break ®LIF®; ...                    // terminate if
+                                        ... continue ®LF;® ...   // resume loop
+                                        ... break ®LF®; ...                     // terminate loop
+                                        ... continue ®LW®; ...   // resume loop
+                                        ... break ®LW®; ...               // terminate loop
                                 } // while
                         } // for
                 } else {
                         ... break ®LIF®; ...
+                        ... break ®LIF®; ...                                     // terminate if
                 } // if
         } // switch
 …
 } ®LC:® ;
 \end{cfa}
+&
-\begin{cfa}
-// terminate compound
-// terminate switch
-// terminate if
-// continue loop
-// terminate loop
-// continue loop
-// terminate loop
-// terminate if
-\end{cfa}
 \end{tabular}
 \caption{Multi-level Exit}
 \label{f:MultiLevelExit}
+\caption{Multi-level Resume/Termination}
+\label{f:MultiLevelResumeTermination}
 \end{figure}
+\begin{comment}
+int main() {
+  LC: {
+          LS: switch ( 1 ) {
+                  case 3:
+                  LIF: if ( 1 ) {
+                          LF: for ( ;; ) {
+                                  LW: while ( 1 ) {
+                                                break LC;                       // terminate compound
+                                                break LS;                       // terminate switch
+                                                break LIF;                      // terminate if
+                                                continue LF;     // resume loop
+                                                break LF;                       // terminate loop
+                                                continue LW;     // resume loop
+                                                break LW;                 // terminate loop
+                                        } // while
+                                } // for
+                        } else {
+                                break LIF;                                       // terminate if
+                        } // if
+                } // switch
+        } // compound
+        {
+                switch ( 1 ) {
+                  case 3:
+                        if ( 1 ) {
+                                for ( ;; ) {
+                                        while ( 1 ) {
+                                                goto LCx;
+                                                goto LSx;
+                                                goto LIF;
+                                                goto LFC;
+                                                goto LFB;
+                                                goto LWC;
+                                                goto LWB;
+                                          LWC: ; } LWB: ;
+                                  LFC: ; } LFB: ;
+                        } else {
+                                goto LIF;
+                        } L3: ;
+                } LSx: ;
+        } LCx: ;
+}
+// Local Variables: //
+// tab-width: 4 //
+// End: //
+\end{comment}
 Both labelled ©continue© and ©break© are a ©goto©\index{goto@\lstinline $goto$!restricted} restricted in the following ways:
 …
 \item
 They cannot branch into a control structure.
 This restriction prevents missing declarations and/or initializations at the start of a control structure resulting in undefined behaviour.
+This restriction prevents missing initialization at the start of a control structure resulting in undefined behaviour.
 \end{itemize}
 The advantage of the labelled ©continue©/©break© is allowing static multi-level exits without having to use the ©goto© statement, and tying control flow to the target control structure rather than an arbitrary point in a program.
 Furthermore, the location of the label at the \emph{beginning} of the target control structure informs the reader (\Index{eye candy}) that complex control-flow is occurring in the body of the control structure.
+Furthermore, the location of the label at the \emph{beginning} of the target control structure informs the reader that complex control-flow is occurring in the body of the control structure.
 With ©goto©, the label is at the end of the control structure, which fails to convey this important clue early enough to the reader.
 Finally, using an explicit target for the transfer instead of an implicit target allows new constructs to be added or removed without affecting existing constructs.
 …
 The problem with this usage is branching into control structures, which is known to cause both comprehension and technical difficulties.
 The comprehension problem occurs from the inability to determine how control reaches a particular point due to the number of branches leading to it.
+The technical problem results from the inability to ensure declaration and initialization of variables when blocks are not entered at the beginning.
+There are no positive arguments for this kind of control flow, and therefore, there is a strong impetus to eliminate it.
+The technical problem results from the inability to ensure allocation and initialization of variables when blocks are not entered at the beginning.
+Often transferring into a block can bypass variable declaration and/or its initialization, which results in subsequent errors.
+There are virtually no positive arguments for this kind of control flow, and therefore, there is a strong impetus to eliminate it.
 Nevertheless, C does have an idiom where this capability is used, known as ``\Index*{Duff's device}''~\cite{Duff83}:
 \begin{cfa}
 …
 class C {
         int i, j;
         int mem() {                                     §\C{\color{red}// implicit "this" parameter}§
                 i = 1;                                  §\C{\color{red}// this->i}§
+                j = 2;                                  §\C{\color{red}// this->j}§
+        }
+        int mem() {              ®// implicit "this" parameter
+                i = 1;          ®// this->i
+®               j = 3;          ®// this->j
+®       }
+}
 \end{C++}
 Since CFA is non-object-oriented, the equivalent object-oriented program looks like:
 \begin{cfa}
+struct S { int i, j; };
+int mem( S &®this® ) {                  §\C{// explicit "this" parameter}§
+        ®this.®i = 1;                           §\C{// "this" is not elided}§
+struct C {
+        int i, j;
+};
+int mem( C &this ) {    // explicit "this" parameter
+        ®this.®i = 1;                     // "this" is not elided
         ®this.®j = 2;
+}
 \end{cfa}
 but it is cumbersome having to write "©this.©" many times in a member.
+\CFA provides a ©with© clause/statement (see Pascal~\cite[\S~4.F]{Pascal}) to elided the "©this.©" by opening a scope containing field identifiers, changing the qualified fields into variables and giving an opportunity for optimizing qualified references.
+\begin{cfa}
+int mem( S &this ) ®with this® { §\C{// with clause}§
+        i = 1;                                          §\C{\color{red}// this->i}§
+        j = 2;                                          §\C{\color{red}// this->j}§
+}
+\CFA provides a ©with© clause/statement to elided the "©this.©".
+\begin{cfa}
+int mem( C &this ) ®with this® {
+        i = 1;                  ®// this.i
+®       j = 2;                  ®// this.j
+®}
 \end{cfa}
 which extends to multiple routine parameters:
 \begin{cfa}
+struct T { double m, n; };
+int mem2( S &this1, T &this2 ) ®with this1, this2® {
+struct D {
+        double m, n;
+};
+int mem2( C &this1, D &this2 ) ®with this1, this2® {
         i = 1; j = 2;
         m = 1.0; n = 2.0;
+}
 \end{cfa}
+The ©with© clause/statement comes from Pascal~\cite[\S~4.F]{Pascal}.
 The statement form is used within a block:
 …
         struct S1 { ... } s1;
         struct S2 { ... } s2;
         ®with s1® {                     // with statement
+        ®with s1® {
                 // access fields of s1 without qualification
                 ®with s2® {  // nesting
                         // access fields of s1 and s2 without qualification
+                        // access fields of s2 without qualification
+                }
+        }
 …
 \end{cfa}
+When opening multiple structures, fields with the same name and type are ambiguous and must be fully qualified.
+For fields with the same name but different type, context/cast can be used to disambiguate.
+\begin{cfa}
+struct S { int i; int j; double m; } a, c;
+struct T { int i; int k; int m } b, c;
+Names clashes when opening multiple structures are ambiguous.
+\begin{cfa}
+struct A { int i; int j; } a, c;
+struct B { int i; int k; } b, c;
 ®with a, b® {
+        j + k;                                          §\C{// unambiguous, unique names define unique types}§
+        i;                                                      §\C{// ambiguous, same name and type}§
+        a.i + b.i;                                      §\C{// unambiguous, qualification defines unique names}§
+        m;                                                      §\C{// ambiguous, same name and no context to define unique type}§
+        m = 5.0;                                        §\C{// unambiguous, same name and context defines unique type}§
+        m = 1;                                          §\C{// unambiguous, same name and context defines unique type}§
+}
+®with c® { ... }                                §\C{// ambiguous, same name and no context}§
+®with (S)c® { ... }                             §\C{// unambiguous, same name and cast defines unique type}§
+        j + k;                                          §\C{// unambiguous}§
+        i;                                                      §\C{// ambiguous}§
+        a.i + b.i;                                      §\C{// unambiguous}§
+}
+®with c® {                                              §\C{// ambiguous}§
+        // ...
+}
 \end{cfa}
 \section{Exception Handling}
-\label{s:ExceptionHandling}
 Exception handling provides two mechanism: change of control flow from a raise to a handler, and communication from the raise to the handler.
+Transfer of control can be local, within a routine, or non-local, among routines.
+Non-local transfer can cause stack unwinding, \ie non-local routine termination, depending on the kind of raise.
+\begin{cfa}
+exception_t E {};                               §\C{// exception type}§
+\begin{cfa}
+exception void h( int i );
+exception int h( int i, double d );
 void f(...) {
+        ... throw E{}; ...                      §\C{// termination}§
+        ... throwResume E{}; ...        §\C{// resumption}§
+}
+        ... throw h( 3 );
+        ... i = resume h( 3, 5.1 );
+}
 try {
         f(...);
 } catch( E e : §boolean-predicate§ ) {                  §\C[8cm]{// termination handler}§
         // recover and continue
 } catchResume( E e : §boolean-predicate§ ) {    §\C{// resumption handler}\CRT§
         // repair and return
+} catch h( int w ) {
+        // reset
+} resume h( int p, double x ) {
+        return 17;  // recover
 } finally {
+        // always executed
+}
+\end{cfa}
+The kind of raise and handler match: ©throw© with ©catch© and ©throwResume© with ©catchResume©.
+Then the exception type must match along with any additonal predicate must be true.
+The ©catch© and ©catchResume© handlers may appear in any oder.
+However, the ©finally© clause must appear at the end of the ©try© statement.
+}
+\end{cfa}
+So the type raised would be the mangled name of the exception prototype and that name would be matched at the handler clauses by comparing the strings.
+The arguments for the call would have to be packed in a message and unpacked at handler clause and then a call made to the handler.
 …
-\section{Exponentiation Operator}
-C, \CC, and Java (and many other programming languages) have no exponentiation operator\index{exponentiation!operator}\index{operator!exponentiation}, \ie $x^y$, and instead use a routine, like \Indexc{pow}, to perform the exponentiation operation.
-\CFA extends the basic operators with the exponentiation operator ©?\?©\index{?\\?@\lstinline$?\?$} and ©?\=?©\index{?\\=?@\lstinline$?\=?$}, as in, ©x \ y© and ©x \= y©, which means $x^y$ and $x \leftarrow x^y$.
-The priority of the exponentiation operator is between the cast and multiplicative operators, so that ©w * (int)x \ (int)y * z© is parenthesized as ©((w * (((int)x) \ ((int)y))) * z)©.
-As for \Index{division}, there are exponentiation operators for integral and floating-point types, including the builtin \Index{complex} types.
-Unsigned integral exponentiation\index{exponentiation!unsigned integral} is performed with repeated multiplication\footnote{The multiplication computation is optimized to $O(\log y)$.} (or shifting if the base is 2).
-Signed integral exponentiation\index{exponentiation!signed integral} is performed with repeated multiplication (or shifting if the base is 2), but yields a floating-point result because $x^{-y}=1/x^y$.
-Hence, it is important to designate exponent integral-constants as unsigned or signed: ©3 \ 3u© return an integral result, while ©3 \ 3© returns a floating-point result.
-Floating-point exponentiation\index{exponentiation!floating point} is performed using \Index{logarithm}s\index{exponentiation!logarithm}, so the base cannot be negative.
-\begin{cfa}
-sout | 2 ®\® 8u | 4 ®\® 3u | -4 ®\® 3u | 4 ®\® -3 | -4 ®\® -3 | 4.0 ®\® 2.1 | (1.0f+2.0fi) ®\® (3.0f+2.0fi) | endl;
-64 -64 0.015625 -0.015625 18.3791736799526 0.264715-1.1922i
-\end{cfa}
-Parenthesis are necessary for the complex constants or the expresion is parsed as ©1.0f+(2.0fi \ 3.0f)+2.0fi©.
-The exponentiation operator is available for all the basic types, but for user-defined types, only the integral-computation versions are available.
-For returning an integral value, the user type ©T© must define multiplication, ©*©, and one, ©1©;
-for returning a floating-point value, an additional divide of type ©T© into a ©double© returning a ©double© (©double ?/?( double, T )©) is necessary for negative exponents.
 \section{Pointer / Reference}
 …
 An integer constant expression with the value 0, or such an expression cast to type ©void *©, is called a \newterm{null-pointer constant}.\footnote{
 One way to conceptualize the null pointer is that no variable is placed at this address, so the null-pointer address can be used to denote an uninitialized pointer/reference object;
+\ie the null pointer is guaranteed to compare unequal to a pointer to any object or routine.
+In general, a value with special meaning among a set of values is called a \emph{\Index{sentinel value}}, \eg ©-1© as a return code value.}
+\ie the null pointer is guaranteed to compare unequal to a pointer to any object or routine.}
 An address is \newterm{sound}, if it points to a valid memory location in scope, \ie within the program's execution-environment and has not been freed.
 Dereferencing an \newterm{unsound} address, including the null pointer, is \Index{undefined}, often resulting in a \Index{memory fault}.
 …
 \hline
 \begin{cfa}
 lda             r1,100  // load address of x
 ld               r2,(r1)          // load value of x
 lda             r3,104  // load address of y
 st               r2,(r3)          // store x into y
+lda             r1,100                  // load address of x
+ld               r2,(r1)                  // load value of x
+lda             r3,104                  // load address of y
+st               r2,(r3)                  // store x into y
 \end{cfa}
+&
 \begin{cfa}
 ld              r2,(100)        // load value of x
 st              r2,(104)        // store x into y
+ld              r2,(100)                // load value of x
+st              r2,(104)                // store x into y
 \end{cfa}
 \end{tabular}
 …
 int w, x, y, z, & ar[3] = { x, y, z }; §\C{// initialize array of references}§
 &ar[1] = &w;                                            §\C{// change reference array element}§
 typeof( ar[1] ) p;                                      §\C{// (gcc) is int, \ie the type of referenced object}§
 typeof( &ar[1] ) q;                                     §\C{// (gcc) is int \&, \ie the type of reference}§
 sizeof( ar[1] ) == sizeof( int );       §\C{// is true, \ie the size of referenced object}§
 sizeof( &ar[1] ) == sizeof( int *)      §\C{// is true, \ie the size of a reference}§
+typeof( ar[1] ) p;                                      §\C{// (gcc) is int, i.e., the type of referenced object}§
+typeof( &ar[1] ) q;                                     §\C{// (gcc) is int \&, i.e., the type of reference}§
+sizeof( ar[1] ) == sizeof( int );       §\C{// is true, i.e., the size of referenced object}§
+sizeof( &ar[1] ) == sizeof( int *)      §\C{// is true, i.e., the size of a reference}§
 \end{cfa}
 …
 \item
 lvalue to reference conversion: \lstinline[deletekeywords=lvalue]$lvalue-type cv1 T$ converts to ©cv2 T &©, which allows implicitly converting variables to references.
+lvalue to reference conversion: \lstinline[deletekeywords={lvalue}]@lvalue-type cv1 T@ converts to ©cv2 T &©, which allows implicitly converting variables to references.
 \begin{cfa}
 int x, &r = ®x®, f( int & p ); // lvalue variable (int) convert to reference (int &)
 …
 In detail, the brackets, ©[]©, enclose the result type, where each return value is named and that name is a local variable of the particular return type.\footnote{
 \Index*{Michael Tiemann}\index{Tiemann, Michael}, with help from \Index*{Doug Lea}\index{Lea, Doug}, provided named return values in g++, circa 1989.}
+\Index*{Michael Tiemann}, with help from \Index*{Doug Lea}, provided named return values in g++, circa 1989.}
 The value of each local return variable is automatically returned at routine termination.
 Declaration qualifiers can only appear at the start of a routine definition, \eg:
 …
-\section{Tuple}
-In C and \CFA, lists of elements appear in several contexts, such as the parameter list of a routine call.
-\begin{cfa}
-f( ®2, x, 3 + i® );                             §\C{// element list}§
-\end{cfa}
-A list of elements is called a \newterm{tuple}, and is different from a \Index{comma expression}.
-\subsection{Multiple-Return-Value Functions}
-\label{s:MRV_Functions}
-In standard C, functions can return at most one value.
-To emulate functions with multiple return values, \emph{\Index{aggregation}} and/or \emph{\Index{aliasing}} is used.
-In the former situation, the function designer creates a record type that combines all of the return values into a single type.
-For example, consider a function returning the most frequently occurring letter in a string, and its frequency.
-This example is complex enough to illustrate that an array is insufficient, since arrays are homogeneous, and demonstrates a potential pitfall that exists with aliasing.
-\begin{cfa}
-struct mf_ret {
-        int freq;
-        char ch;
-};
-struct mf_ret most_frequent(const char * str) {
-        char freqs [26] = { 0 };
-        struct mf_ret ret = { 0, 'a' };
-        for (int i = 0; str[i] != '\0'; ++i) {
-                if (isalpha(str[i])) {        // only count letters
-                        int ch = tolower(str[i]);   // convert to lower case
-                        int idx = ch-'a';
-                        if (++freqs[idx] > ret.freq) {  // update on new max
-                          ret.freq = freqs[idx];
-                          ret.ch = ch;
+                        }
+                }
+        }
-        return ret;
+}
-const char * str = "hello world";
-struct mf_ret ret = most_frequent(str);
-printf("%s -- %d %c\n", str, ret.freq, ret.ch);
-\end{cfa}
-Of note, the designer must come up with a name for the return type and for each of its fields.
-Unnecessary naming is a common programming language issue, introducing verbosity and a complication of the user's mental model.
-That is, adding another named type creates another association in the programmer's mind that needs to be kept track of when reading and writing code.
-As such, this technique is effective when used sparingly, but can quickly get out of hand if many functions need to return different combinations of types.
-In the latter approach, the designer simulates multiple return values by passing the additional return values as pointer parameters.
-The pointer parameters are assigned inside of the routine body to emulate a return.
-Using the same example,
-\begin{cfa}
-int most_frequent(const char * str, char * ret_ch) {
-        char freqs [26] = { 0 };
-        int ret_freq = 0;
-        for (int i = 0; str[i] != '\0'; ++i) {
-                if (isalpha(str[i])) {        // only count letters
-                        int ch = tolower(str[i]);   // convert to lower case
-                        int idx = ch-'a';
-                        if (++freqs[idx] > ret_freq) {  // update on new max
-                          ret_freq = freqs[idx];
-                          *ret_ch = ch;   // assign to out parameter
+                        }
+                }
+        }
-        return ret_freq;  // only one value returned directly
+}
-const char * str = "hello world";
-char ch;                            // pre-allocate return value
-int freq = most_frequent(str, &ch); // pass return value as out parameter
-printf("%s -- %d %c\n", str, freq, ch);
-\end{cfa}
-Notably, using this approach, the caller is directly responsible for allocating storage for the additional temporary return values, which complicates the call site with a sequence of variable declarations leading up to the call.
-Also, while a disciplined use of ©const© can give clues about whether a pointer parameter is going to be used as an out parameter, it is not immediately obvious from only the routine signature whether the callee expects such a parameter to be initialized before the call.
-Furthermore, while many C routines that accept pointers are designed so that it is safe to pass ©NULL© as a parameter, there are many C routines that are not null-safe.
-On a related note, C does not provide a standard mechanism to state that a parameter is going to be used as an additional return value, which makes the job of ensuring that a value is returned more difficult for the compiler.
-Interestingly, there is a subtle bug in the previous example, in that ©ret_ch© is never assigned for a string that does not contain any letters, which can lead to undefined behaviour.
-In this particular case, it turns out that the frequency return value also doubles as an error code, where a frequency of 0 means the character return value should be ignored.
-Still, not every routine with multiple return values should be required to return an error code, and error codes are easily ignored, so this is not a satisfying solution.
-As with the previous approach, this technique can simulate multiple return values, but in practice it is verbose and error prone.
-In \CFA, functions can be declared to return multiple values with an extension to the function declaration syntax.
-Multiple return values are declared as a comma-separated list of types in square brackets in the same location that the return type appears in standard C function declarations.
-The ability to return multiple values from a function requires a new syntax for the return statement.
-For consistency, the return statement in \CFA accepts a comma-separated list of expressions in square brackets.
-The expression resolution phase of the \CFA translator ensures that the correct form is used depending on the values being returned and the return type of the current function.
-A multiple-returning function with return type ©T© can return any expression that is implicitly convertible to ©T©.
-Using the running example, the ©most_frequent© function can be written using multiple return values as such,
-\begin{cfa}
-[int, char] most_frequent(const char * str) {
-        char freqs [26] = { 0 };
-        int ret_freq = 0;
-        char ret_ch = 'a';  // arbitrary default value for consistent results
-        for (int i = 0; str[i] != '\0'; ++i) {
-                if (isalpha(str[i])) {        // only count letters
-                        int ch = tolower(str[i]);   // convert to lower case
-                        int idx = ch-'a';
-                        if (++freqs[idx] > ret_freq) {  // update on new max
-                          ret_freq = freqs[idx];
-                          ret_ch = ch;
+                        }
+                }
+        }
-        return [ret_freq, ret_ch];
+}
-\end{cfa}
-This approach provides the benefits of compile-time checking for appropriate return statements as in aggregation, but without the required verbosity of declaring a new named type, which precludes the bug seen with out-parameters.
-The addition of multiple-return-value functions necessitates a syntax for accepting multiple values at the call-site.
-The simplest mechanism for retaining a return value in C is variable assignment.
-By assigning the return value into a variable, its value can be retrieved later at any point in the program.
-As such, \CFA allows assigning multiple values from a function into multiple variables, using a square-bracketed list of lvalue expressions on the left side.
-\begin{cfa}
-const char * str = "hello world";
-int freq;
-char ch;
-[freq, ch] = most_frequent(str);  // assign into multiple variables
-printf("%s -- %d %c\n", str, freq, ch);
-\end{cfa}
-It is also common to use a function's output as the input to another function.
-\CFA also allows this case, without any new syntax.
-When a function call is passed as an argument to another call, the expression resolver attempts to find the best match of actual arguments to formal parameters given all of the possible expression interpretations in the current scope \cite{Bilson03}.
-For example,
-\begin{cfa}
-void process(int);       // (1)
-void process(char);      // (2)
-void process(int, char); // (3)
-void process(char, int); // (4)
-process(most_frequent("hello world"));  // selects (3)
-\end{cfa}
-In this case, there is only one option for a function named ©most_frequent© that takes a string as input.
-This function returns two values, one ©int© and one ©char©.
-There are four options for a function named ©process©, but only two that accept two arguments, and of those the best match is (3), which is also an exact match.
-This expression first calls ©most_frequent("hello world")©, which produces the values ©3© and ©'l'©, which are fed directly to the first and second parameters of (3), respectively.
-\section{Tuple Expressions}
-Multiple-return-value functions provide \CFA with a new syntax for expressing a combination of expressions in the return statement and a combination of types in a function signature.
-These notions can be generalized to provide \CFA with \emph{tuple expressions} and \emph{tuple types}.
-A tuple expression is an expression producing a fixed-size, ordered list of values of heterogeneous types.
-The type of a tuple expression is the tuple of the subexpression types, or a \emph{tuple type}.
-In \CFA, a tuple expression is denoted by a comma-separated list of expressions enclosed in square brackets.
-For example, the expression ©[5, 'x', 10.5]© has type ©[int, char, double]©.
-The previous expression has 3 \emph{components}.
-Each component in a tuple expression can be any \CFA expression, including another tuple expression.
-The order of evaluation of the components in a tuple expression is unspecified, to allow a compiler the greatest flexibility for program optimization.
-It is, however, guaranteed that each component of a tuple expression is evaluated for side-effects, even if the result is not used.
-Multiple-return-value functions can equivalently be called \emph{tuple-returning functions}.
-\subsection{Tuple Variables}
-The call-site of the ©most_frequent© routine has a notable blemish, in that it required the preallocation of return variables in a manner similar to the aliasing example, since it is impossible to declare multiple variables of different types in the same declaration in standard C.
-In \CFA, it is possible to overcome this restriction by declaring a \emph{tuple variable}.
-\begin{cfa}[emph=ret, emphstyle=\color{red}]
-const char * str = "hello world";
-[int, char] ret = most_frequent(str);  // initialize tuple variable
-printf("%s -- %d %c\n", str, ret);
-\end{cfa}
-It is now possible to accept multiple values into a single piece of storage, in much the same way that it was previously possible to pass multiple values from one function call to another.
-These variables can be used in any of the contexts where a tuple expression is allowed, such as in the ©printf© function call.
-As in the ©process© example, the components of the tuple value are passed as separate parameters to ©printf©, allowing very simple printing of tuple expressions.
-One way to access the individual components is with a simple assignment, as in previous examples.
-\begin{cfa}
-int freq;
-char ch;
-[freq, ch] = ret;
-\end{cfa}
-\begin{sloppypar}
-In addition to variables of tuple type, it is also possible to have pointers to tuples, and arrays of tuples.
-Tuple types can be composed of any types, except for array types, since array assignment is disallowed, which makes tuple assignment difficult when a tuple contains an array.
-\begin{cfa}
-[double, int] di;
-[double, int] * pdi
-[double, int] adi[10];
-\end{cfa}
-This examples declares a variable of type ©[double, int]©, a variable of type pointer to ©[double, int]©, and an array of ten ©[double, int]©.
-\end{sloppypar}
-\subsection{Tuple Indexing}
-At times, it is desirable to access a single component of a tuple-valued expression without creating unnecessary temporary variables to assign to.
-Given a tuple-valued expression ©e© and a compile-time constant integer $i$ where $0 \leq i < n$, where $n$ is the number of components in ©e©, ©e.i© accesses the $i$\textsuperscript{th} component of ©e©.
-For example,
-\begin{cfa}
-[int, double] x;
-[char *, int] f();
-void g(double, int);
-[int, double] * p;
-int y = x.0;                                                    §\C{// access int component of x}§
-y = f().1;                                                              §\C{// access int component of f}§
-p->0 = 5;                                                               §\C{// access int component of tuple pointed-to by p}§
-g( x.1, x.0 );                                                  §\C{// rearrange x to pass to g}§
-double z = [x, f()].0.1;                                §\C{// access second component of first component of tuple expression}§
-\end{cfa}
-As seen above, tuple-index expressions can occur on any tuple-typed expression, including tuple-returning functions, square-bracketed tuple expressions, and other tuple-index expressions, provided the retrieved component is also a tuple.
-This feature was proposed for \KWC but never implemented \cite[p.~45]{Till89}.
-\subsection{Flattening and Structuring}
-As evident in previous examples, tuples in \CFA do not have a rigid structure.
-In function call contexts, tuples support implicit flattening and restructuring conversions.
-Tuple flattening recursively expands a tuple into the list of its basic components.
-Tuple structuring packages a list of expressions into a value of tuple type.
-\begin{cfa}
-int f(int, int);
-int g([int, int]);
-int h(int, [int, int]);
-[int, int] x;
-int y;
-f(x);      // flatten
-g(y, 10);  // structure
-h(x, y);   // flatten & structure
-\end{cfa}
-In \CFA, each of these calls is valid.
-In the call to ©f©, ©x© is implicitly flattened so that the components of ©x© are passed as the two arguments to ©f©.
-For the call to ©g©, the values ©y© and ©10© are structured into a single argument of type ©[int, int]© to match the type of the parameter of ©g©.
-Finally, in the call to ©h©, ©x© is flattened to yield an argument list of length 3, of which the first component of ©x© is passed as the first parameter of ©h©, and the second component of ©x© and ©y© are structured into the second argument of type ©[int, int]©.
-The flexible structure of tuples permits a simple and expressive function-call syntax to work seamlessly with both single- and multiple-return-value functions, and with any number of arguments of arbitrarily complex structure.
-In \KWC \cite{Buhr94a,Till89}, there were 4 tuple coercions: opening, closing, flattening, and structuring.
-Opening coerces a tuple value into a tuple of values, while closing converts a tuple of values into a single tuple value.
-Flattening coerces a nested tuple into a flat tuple, \ie it takes a tuple with tuple components and expands it into a tuple with only non-tuple components.
-Structuring moves in the opposite direction, \ie it takes a flat tuple value and provides structure by introducing nested tuple components.
-In \CFA, the design has been simplified to require only the two conversions previously described, which trigger only in function call and return situations.
-This simplification is a primary contribution of this thesis to the design of tuples in \CFA.
-Specifically, the expression resolution algorithm examines all of the possible alternatives for an expression to determine the best match.
-In resolving a function call expression, each combination of function value and list of argument alternatives is examined.
-Given a particular argument list and function value, the list of argument alternatives is flattened to produce a list of non-tuple valued expressions.
-Then the flattened list of expressions is compared with each value in the function's parameter list.
-If the parameter's type is not a tuple type, then the current argument value is unified with the parameter type, and on success the next argument and parameter are examined.
-If the parameter's type is a tuple type, then the structuring conversion takes effect, recursively applying the parameter matching algorithm using the tuple's component types as the parameter list types.
-Assuming a successful unification, eventually the algorithm gets to the end of the tuple type, which causes all of the matching expressions to be consumed and structured into a tuple expression.
-For example, in
-\begin{cfa}
-int f(int, [double, int]);
-f([5, 10.2], 4);
-\end{cfa}
-There is only a single definition of ©f©, and 3 arguments with only single interpretations.
-First, the argument alternative list ©[5, 10.2], 4© is flattened to produce the argument list ©5, 10.2, 4©.
-Next, the parameter matching algorithm begins, with $P = $©int© and $A = $©int©, which unifies exactly.
-Moving to the next parameter and argument, $P = $©[double, int]© and $A = $©double©.
-This time, the parameter is a tuple type, so the algorithm applies recursively with $P' = $©double© and $A = $©double©, which unifies exactly.
-Then $P' = $©int© and $A = $©double©, which again unifies exactly.
-At this point, the end of $P'$ has been reached, so the arguments ©10.2, 4© are structured into the tuple expression ©[10.2, 4]©.
-Finally, the end of the parameter list $P$ has also been reached, so the final expression is ©f(5, [10.2, 4])©.
-\section{Tuple Assignment}
-\label{s:TupleAssignment}
-An assignment where the left side of the assignment operator has a tuple type is called tuple assignment.
-There are two kinds of tuple assignment depending on whether the right side of the assignment operator has a tuple type or a non-tuple type, called \emph{Multiple} and \emph{Mass} Assignment, respectively.
-\begin{cfa}
-int x;
-double y;
-[int, double] z;
-[y, x] = 3.14;  // mass assignment
-[x, y] = z;     // multiple assignment
-z = 10;         // mass assignment
-z = [x, y];     // multiple assignment
-\end{cfa}
-Let $L_i$ for $i$ in $[0, n)$ represent each component of the flattened left side, $R_i$ represent each component of the flattened right side of a multiple assignment, and $R$ represent the right side of a mass assignment.
-For a multiple assignment to be valid, both tuples must have the same number of elements when flattened.
-For example, the following is invalid because the number of components on the left does not match the number of components on the right.
-\begin{cfa}
-[int, int] x, y, z;
-[x, y] = z;   // multiple assignment, invalid 4 != 2
-\end{cfa}
-Multiple assignment assigns $R_i$ to $L_i$ for each $i$.
-That is, ©?=?(&$L_i$, $R_i$)© must be a well-typed expression.
-In the previous example, ©[x, y] = z©, ©z© is flattened into ©z.0, z.1©, and the assignments ©x = z.0© and ©y = z.1© happen.
-A mass assignment assigns the value $R$ to each $L_i$.
-For a mass assignment to be valid, ©?=?(&$L_i$, $R$)© must be a well-typed expression.
-These semantics differ from C cascading assignment (\eg ©a=b=c©) in that conversions are applied to $R$ in each individual assignment, which prevents data loss from the chain of conversions that can happen during a cascading assignment.
-For example, ©[y, x] = 3.14© performs the assignments ©y = 3.14© and ©x = 3.14©, which results in the value ©3.14© in ©y© and the value ©3© in ©x©.
-On the other hand, the C cascading assignment ©y = x = 3.14© performs the assignments ©x = 3.14© and ©y = x©, which results in the value ©3© in ©x©, and as a result the value ©3© in ©y© as well.
-Both kinds of tuple assignment have parallel semantics, such that each value on the left side and right side is evaluated \emph{before} any assignments occur.
-As a result, it is possible to swap the values in two variables without explicitly creating any temporary variables or calling a function.
-\begin{cfa}
-int x = 10, y = 20;
-[x, y] = [y, x];
-\end{cfa}
-After executing this code, ©x© has the value ©20© and ©y© has the value ©10©.
-In \CFA, tuple assignment is an expression where the result type is the type of the left side of the assignment, as in normal assignment.
-That is, a tuple assignment produces the value of the left-hand side after assignment.
-These semantics allow cascading tuple assignment to work out naturally in any context where a tuple is permitted.
-These semantics are a change from the original tuple design in \KWC \cite{Till89}, wherein tuple assignment was a statement that allows cascading assignments as a special case.
-Restricting tuple assignment to statements was an attempt to to fix what was seen as a problem with side-effects, wherein assignment can be used in many different locations, such as in function-call argument position.
-While permitting assignment as an expression does introduce the potential for subtle complexities, it is impossible to remove assignment expressions from \CFA without affecting backwards compatibility.
-Furthermore, there are situations where permitting assignment as an expression improves readability by keeping code succinct and reducing repetition, and complicating the definition of tuple assignment puts a greater cognitive burden on the user.
-In another language, tuple assignment as a statement could be reasonable, but it would be inconsistent for tuple assignment to be the only kind of assignment that is not an expression.
-In addition, \KWC permits the compiler to optimize tuple assignment as a block copy, since it does not support user-defined assignment operators.
-This optimization could be implemented in \CFA, but it requires the compiler to verify that the selected assignment operator is trivial.
-The following example shows multiple, mass, and cascading assignment used in one expression
-\begin{cfa}
-        int a, b;
-        double c, d;
-        [void] f([int, int]);
-        f([c, a] = [b, d] = 1.5);  // assignments in parameter list
-\end{cfa}
-The tuple expression begins with a mass assignment of ©1.5© into ©[b, d]©, which assigns ©1.5© into ©b©, which is truncated to ©1©, and ©1.5© into ©d©, producing the tuple ©[1, 1.5]© as a result.
-That tuple is used as the right side of the multiple assignment (\ie, ©[c, a] = [1, 1.5]©) that assigns ©1© into ©c© and ©1.5© into ©a©, which is truncated to ©1©, producing the result ©[1, 1]©.
-Finally, the tuple ©[1, 1]© is used as an expression in the call to ©f©.
-\subsection{Tuple Construction}
-Tuple construction and destruction follow the same rules and semantics as tuple assignment, except that in the case where there is no right side, the default constructor or destructor is called on each component of the tuple.
-As constructors and destructors did not exist in previous versions of \CFA or in \KWC, this is a primary contribution of this thesis to the design of tuples.
-\begin{cfa}
-struct S;
-void ?{}(S *);         // (1)
-void ?{}(S *, int);    // (2)
-void ?{}(S * double);  // (3)
-void ?{}(S *, S);      // (4)
-[S, S] x = [3, 6.28];  // uses (2), (3), specialized constructors
-[S, S] y;              // uses (1), (1), default constructor
-[S, S] z = x.0;        // uses (4), (4), copy constructor
-\end{cfa}
-In this example, ©x© is initialized by the multiple constructor calls ©?{}(&x.0, 3)© and ©?{}(&x.1, 6.28)©, while ©y© is initialized by two default constructor calls ©?{}(&y.0)© and ©?{}(&y.1)©.
-©z© is initialized by mass copy constructor calls ©?{}(&z.0, x.0)© and ©?{}(&z.1, x.0)©.
-Finally, ©x©, ©y©, and ©z© are destructed, \ie the calls ©^?{}(&x.0)©, ©^?{}(&x.1)©, ©^?{}(&y.0)©, ©^?{}(&y.1)©, ©^?{}(&z.0)©, and ©^?{}(&z.1)©.
-It is possible to define constructors and assignment functions for tuple types that provide new semantics, if the existing semantics do not fit the needs of an application.
-For example, the function ©void ?{}([T, U] *, S);© can be defined to allow a tuple variable to be constructed from a value of type ©S©.
-\begin{cfa}
-struct S { int x; double y; };
-void ?{}([int, double] * this, S s) {
-        this->0 = s.x;
-        this->1 = s.y;
+}
-\end{cfa}
-Due to the structure of generated constructors, it is possible to pass a tuple to a generated constructor for a type with a member prefix that matches the type of the tuple.
-For example,
-\begin{cfa}
-struct S { int x; double y; int z };
-[int, double] t;
-S s = t;
-\end{cfa}
-The initialization of ©s© with ©t© works by default because ©t© is flattened into its components, which satisfies the generated field constructor ©?{}(S *, int, double)© to initialize the first two values.
-\section{Member-Access Tuple Expression}
-\label{s:MemberAccessTuple}
-It is possible to access multiple fields from a single expression using a \emph{Member-Access Tuple Expression}.
-The result is a single tuple-valued expression whose type is the tuple of the types of the members.
-For example,
-\begin{cfa}
-struct S { int x; double y; char * z; } s;
-s.[x, y, z];
-\end{cfa}
-Here, the type of ©s.[x, y, z]© is ©[int, double, char *]©.
-A member tuple expression has the form ©a.[x, y, z];© where ©a© is an expression with type ©T©, where ©T© supports member access expressions, and ©x, y, z© are all members of ©T© with types ©T$_x$©, ©T$_y$©, and ©T$_z$© respectively.
-Then the type of ©a.[x, y, z]© is ©[T_x, T_y, T_z]©.
-Since tuple index expressions are a form of member-access expression, it is possible to use tuple-index expressions in conjunction with member tuple expressions to manually restructure a tuple (\eg, rearrange components, drop components, duplicate components, etc.).
-\begin{cfa}
-[int, int, long, double] x;
-void f(double, long);
-f(x.[0, 3]);          // f(x.0, x.3)
-x.[0, 1] = x.[1, 0];  // [x.0, x.1] = [x.1, x.0]
-[long, int, long] y = x.[2, 0, 2];
-\end{cfa}
-It is possible for a member tuple expression to contain other member access expressions.
-For example,
-\begin{cfa}
-struct A { double i; int j; };
-struct B { int * k; short l; };
-struct C { int x; A y; B z; } v;
-v.[x, y.[i, j], z.k];
-\end{cfa}
-This expression is equivalent to ©[v.x, [v.y.i, v.y.j], v.z.k]©.
-That is, the aggregate expression is effectively distributed across the tuple, which allows simple and easy access to multiple components in an aggregate, without repetition.
-It is guaranteed that the aggregate expression to the left of the ©.© in a member tuple expression is evaluated exactly once.
-As such, it is safe to use member tuple expressions on the result of a side-effecting function.
-\begin{cfa}
-[int, float, double] f();
-[double, float] x = f().[2, 1];
-\end{cfa}
-In \KWC, member tuple expressions are known as \emph{record field tuples} \cite{Till89}.
-Since \CFA permits these tuple-access expressions using structures, unions, and tuples, \emph{member tuple expression} or \emph{field tuple expression} is more appropriate.
-It is possible to extend member-access expressions further.
-Currently, a member-access expression whose member is a name requires that the aggregate is a structure or union, while a constant integer member requires the aggregate to be a tuple.
-In the interest of orthogonal design, \CFA could apply some meaning to the remaining combinations as well.
-For example,
-\begin{cfa}
-struct S { int x, y; } s;
-[S, S] z;
-s.x;  // access member
-z.0;  // access component
-s.1;  // ???
-z.y;  // ???
-\end{cfa}
-One possibility is for ©s.1© to select the second member of ©s©.
-Under this interpretation, it becomes possible to not only access members of a struct by name, but also by position.
-Likewise, it seems natural to open this mechanism to enumerations as well, wherein the left side would be a type, rather than an expression.
-One benefit of this interpretation is familiarity, since it is extremely reminiscent of tuple-index expressions.
-On the other hand, it could be argued that this interpretation is brittle in that changing the order of members or adding new members to a structure becomes a brittle operation.
-This problem is less of a concern with tuples, since modifying a tuple affects only the code that directly uses the tuple, whereas modifying a structure has far reaching consequences for every instance of the structure.
-As for ©z.y©, one interpretation is to extend the meaning of member tuple expressions.
-That is, currently the tuple must occur as the member, \ie to the right of the dot.
-Allowing tuples to the left of the dot could distribute the member across the elements of the tuple, in much the same way that member tuple expressions distribute the aggregate across the member tuple.
-In this example, ©z.y© expands to ©[z.0.y, z.1.y]©, allowing what is effectively a very limited compile-time field-sections map operation, where the argument must be a tuple containing only aggregates having a member named ©y©.
-It is questionable how useful this would actually be in practice, since structures often do not have names in common with other structures, and further this could cause maintainability issues in that it encourages programmers to adopt very simple naming conventions to maximize the amount of overlap between different types.
-Perhaps more useful would be to allow arrays on the left side of the dot, which would likewise allow mapping a field access across the entire array, producing an array of the contained fields.
-The immediate problem with this idea is that C arrays do not carry around their size, which would make it impossible to use this extension for anything other than a simple stack allocated array.
-Supposing this feature works as described, it would be necessary to specify an ordering for the expansion of member-access expressions versus member-tuple expressions.
-\begin{cfa}
-struct { int x, y; };
-[S, S] z;
-z.[x, y];  // ???
-// => [z.0, z.1].[x, y]
-// => [z.0.x, z.0.y, z.1.x, z.1.y]
-// or
-// => [z.x, z.y]
-// => [[z.0, z.1].x, [z.0, z.1].y]
-// => [z.0.x, z.1.x, z.0.y, z.1.y]
-\end{cfa}
-Depending on exactly how the two tuples are combined, different results can be achieved.
-As such, a specific ordering would need to be imposed to make this feature useful.
-Furthermore, this addition moves a member-tuple expression's meaning from being clear statically to needing resolver support, since the member name needs to be distributed appropriately over each member of the tuple, which could itself be a tuple.
-A second possibility is for \CFA to have named tuples, as they exist in Swift and D.
-\begin{cfa}
-typedef [int x, int y] Point2D;
-Point2D p1, p2;
-p1.x + p1.y + p2.x + p2.y;
-p1.0 + p1.1 + p2.0 + p2.1;  // equivalent
-\end{cfa}
-In this simpler interpretation, a tuple type carries with it a list of possibly empty identifiers.
-This approach fits naturally with the named return-value feature, and would likely go a long way towards implementing it.
-Ultimately, the first two extensions introduce complexity into the model, with relatively little perceived benefit, and so were dropped from consideration.
-Named tuples are a potentially useful addition to the language, provided they can be parsed with a reasonable syntax.
-\section{Casting}
-In C, the cast operator is used to explicitly convert between types.
-In \CFA, the cast operator has a secondary use, which is type ascription, since it forces the expression resolution algorithm to choose the lowest cost conversion to the target type.
-That is, a cast can be used to select the type of an expression when it is ambiguous, as in the call to an overloaded function.
-\begin{cfa}
-int f();     // (1)
-double f();  // (2)
-f();       // ambiguous - (1),(2) both equally viable
-(int)f();  // choose (2)
-\end{cfa}
-Since casting is a fundamental operation in \CFA, casts need to be given a meaningful interpretation in the context of tuples.
-Taking a look at standard C provides some guidance with respect to the way casts should work with tuples.
-\begin{cfa}[numbers=left]
-int f();
-void g();
-(void)f();  // valid, ignore results
-(int)g();   // invalid, void cannot be converted to int
-struct A { int x; };
-(struct A)f();  // invalid, int cannot be converted to A
-\end{cfa}
-In C, line 4 is a valid cast, which calls ©f© and discards its result.
-On the other hand, line 5 is invalid, because ©g© does not produce a result, so requesting an ©int© to materialize from nothing is nonsensical.
-Finally, line 8 is also invalid, because in C casts only provide conversion between scalar types \cite[p.~91]{C11}.
-For consistency, this implies that any case wherein the number of components increases as a result of the cast is invalid, while casts that have the same or fewer number of components may be valid.
-Formally, a cast to tuple type is valid when $T_n \leq S_m$, where $T_n$ is the number of components in the target type and $S_m$ is the number of components in the source type, and for each $i$ in $[0, n)$, $S_i$ can be cast to $T_i$.
-Excess elements ($S_j$ for all $j$ in $[n, m)$) are evaluated, but their values are discarded so that they are not included in the result expression.
-This discarding naturally follows the way that a cast to void works in C.
-For example,
-\begin{cfa}
-        [int, int, int] f();
-        [int, [int, int], int] g();
-        ([int, double])f();           // (1) valid
-        ([int, int, int])g();         // (2) valid
-        ([void, [int, int]])g();      // (3) valid
-        ([int, int, int, int])g();    // (4) invalid
-        ([int, [int, int, int]])g();  // (5) invalid
-\end{cfa}
-(1) discards the last element of the return value and converts the second element to type double.
-Since ©int© is effectively a 1-element tuple, (2) discards the second component of the second element of the return value of ©g©.
-If ©g© is free of side effects, this is equivalent to ©[(int)(g().0), (int)(g().1.0), (int)(g().2)]©.
-Since ©void© is effectively a 0-element tuple, (3) discards the first and third return values, which is effectively equivalent to ©[(int)(g().1.0), (int)(g().1.1)]©).
-% will this always hold true? probably, as constructors should give all of the conversion power we need. if casts become function calls, what would they look like? would need a way to specify the target type, which seems awkward. Also, C++ basically only has this because classes are closed to extension, while we don't have that problem (can have floating constructors for any type).
-Note that a cast is not a function call in \CFA, so flattening and structuring conversions do not occur for cast expressions.
-As such, (4) is invalid because the cast target type contains 4 components, while the source type contains only 3.
-Similarly, (5) is invalid because the cast ©([int, int, int])(g().1)© is invalid.
-That is, it is invalid to cast ©[int, int]© to ©[int, int, int]©.
-\section{Polymorphism}
-Due to the implicit flattening and structuring conversions involved in argument passing, ©otype© and ©dtype© parameters are restricted to matching only with non-tuple types.
-The integration of polymorphism, type assertions, and monomorphic specialization of tuple-assertions are a primary contribution of this thesis to the design of tuples.
-\begin{cfa}
-forall(otype T, dtype U)
-void f(T x, U * y);
-f([5, "hello"]);
-\end{cfa}
-In this example, ©[5, "hello"]© is flattened, so that the argument list appears as ©5, "hello"©.
-The argument matching algorithm binds ©T© to ©int© and ©U© to ©const char©, and calls the function as normal.
-Tuples can contain otype and dtype components.
-For example, a plus operator can be written to add two triples of a type together.
-\begin{cfa}
-forall(otype T | { T ?+?(T, T); })
-[T, T, T] ?+?([T, T, T] x, [T, T, T] y) {
-        return [x.0+y.0, x.1+y.1, x.2+y.2];
+}
-[int, int, int] x;
-int i1, i2, i3;
-[i1, i2, i3] = x + ([10, 20, 30]);
-\end{cfa}
-Note that due to the implicit tuple conversions, this function is not restricted to the addition of two triples.
-A call to this plus operator type checks as long as a total of 6 non-tuple arguments are passed after flattening, and all of the arguments have a common type that can bind to ©T©, with a pairwise ©?+?© over ©T©.
-For example, these expressions also succeed and produce the same value.
-\begin{cfa}
-([x.0, x.1]) + ([x.2, 10, 20, 30]);  // x + ([10, 20, 30])
-x.0 + ([x.1, x.2, 10, 20, 30]);      // x + ([10, 20, 30])
-\end{cfa}
-This presents a potential problem if structure is important, as these three expressions look like they should have different meanings.
-Furthermore, these calls can be made ambiguous by introducing seemingly different functions.
-\begin{cfa}
-forall(otype T | { T ?+?(T, T); })
-[T, T, T] ?+?([T, T] x, [T, T, T, T]);
-forall(otype T | { T ?+?(T, T); })
-[T, T, T] ?+?(T x, [T, T, T, T, T]);
-\end{cfa}
-It is also important to note that these calls could be disambiguated if the function return types were different, as they likely would be for a reasonable implementation of ©?+?©, since the return type is used in overload resolution.
-Still, these semantics are a deficiency of the current argument matching algorithm, and depending on the function, differing return values may not always be appropriate.
-These issues could be rectified by applying an appropriate conversion cost to the structuring and flattening conversions, which are currently 0-cost conversions in the expression resolver.
-Care would be needed in this case to ensure that exact matches do not incur such a cost.
-\begin{cfa}
-void f([int, int], int, int);
-f([0, 0], 0, 0);    // no cost
-f(0, 0, 0, 0);      // cost for structuring
-f([0, 0,], [0, 0]); // cost for flattening
-f([0, 0, 0], 0);    // cost for flattening and structuring
-\end{cfa}
-Until this point, it has been assumed that assertion arguments must match the parameter type exactly, modulo polymorphic specialization (\ie, no implicit conversions are applied to assertion arguments).
-This decision presents a conflict with the flexibility of tuples.
-\subsection{Assertion Inference}
-\begin{cfa}
-int f([int, double], double);
-forall(otype T, otype U | { T f(T, U, U); })
-void g(T, U);
-g(5, 10.21);
-\end{cfa}
-If assertion arguments must match exactly, then the call to ©g© cannot be resolved, since the expected type of ©f© is flat, while the only ©f© in scope requires a tuple type.
-Since tuples are fluid, this requirement reduces the usability of tuples in polymorphic code.
-To ease this pain point, function parameter and return lists are flattened for the purposes of type unification, which allows the previous example to pass expression resolution.
-This relaxation is made possible by extending the existing thunk generation scheme, as described by Bilson \cite{Bilson03}.
-Now, whenever a candidate's parameter structure does not exactly match the formal parameter's structure, a thunk is generated to specialize calls to the actual function.
-\begin{cfa}
-int _thunk(int _p0, double _p1, double _p2) {
-        return f([_p0, _p1], _p2);
+}
-\end{cfa}
-Essentially, this provides flattening and structuring conversions to inferred functions, improving the compatibility of tuples and polymorphism.
 \section{Tuples}
 …
 \begin{cfa}[belowskip=0pt]
 char store[®sepSize®];                                          §\C{// sepSize is the maximum separator size}§
 strcpy( store, sepGet( sout ) );                          §\C{// copy current separator}§
 sepSet( sout, "_" );                                            §\C{// change separator to underscore}§
+strcpy( store, sepGet( sout ) );
+sepSet( sout, "_" );
 sout | 1 | 2 | 3 | endl;
 \end{cfa}
 …
 \end{cfa}
 \begin{cfa}[belowskip=0pt]
 sepSet( sout, store );                                          §\C{// change separator back to original}§
+sepSet( sout, store );
 sout | 1 | 2 | 3 | endl;
 \end{cfa}
 …
 \begin{table}[hbt]
+\centering
+\input{../refrat/operidents}
+\hfil
+\begin{tabular}[t]{ll}
+%identifier & operation \\ \hline
+©?[?]© & subscripting \impl{?[?]}\\
+©?()© & function call \impl{?()}\\
+©?++© & postfix increment \impl{?++}\\
+©?--© & postfix decrement \impl{?--}\\
+©++?© & prefix increment \impl{++?}\\
+©--?© & prefix decrement \impl{--?}\\
+©*?© & dereference \impl{*?}\\
+©+?© & unary plus \impl{+?}\\
+©-?© & arithmetic negation \impl{-?}\\
+©~?© & bitwise negation \impl{~?}\\
+©!?© & logical complement \impl{"!?}\\
+©?*?© & multiplication \impl{?*?}\\
+©?/?© & division \impl{?/?}\\
+\end{tabular}\hfil
+\begin{tabular}[t]{ll}
+%identifier & operation \\ \hline
+©?%?© & remainder \impl{?%?}\\
+©?+?© & addition \impl{?+?}\\
+©?-?© & subtraction \impl{?-?}\\
+©?<<?© & left shift \impl{?<<?}\\
+©?>>?© & right shift \impl{?>>?}\\
+©?<?© & less than \impl{?<?}\\
+©?<=?© & less than or equal \impl{?<=?}\\
+©?>=?© & greater than or equal \impl{?>=?}\\
+©?>?© & greater than \impl{?>?}\\
+©?==?© & equality \impl{?==?}\\
+©?!=?© & inequality \impl{?"!=?}\\
+©?&?© & bitwise AND \impl{?&?}\\
+\end{tabular}\hfil
+\begin{tabular}[t]{ll}
+%identifier & operation \\ \hline
+©?^?© & exclusive OR \impl{?^?}\\
+©?|?© & inclusive OR \impl{?"|?}\\
+©?=?© & simple assignment \impl{?=?}\\
+©?*=?© & multiplication assignment \impl{?*=?}\\
+©?/=?© & division assignment \impl{?/=?}\\
+©?%=?© & remainder assignment \impl{?%=?}\\
+©?+=?© & addition assignment \impl{?+=?}\\
+©?-=?© & subtraction assignment \impl{?-=?}\\
+©?<<=?© & left-shift assignment \impl{?<<=?}\\
+©?>>=?© & right-shift assignment \impl{?>>=?}\\
+©?&=?© & bitwise AND assignment \impl{?&=?}\\
+©?^=?© & exclusive OR assignment \impl{?^=?}\\
+©?|=?© & inclusive OR assignment \impl{?"|=?}\\
+\end{tabular}
+\hfil
 \caption{Operator Identifiers}
 \label{opids}
 …
 \section{Auto Type-Inferencing}
 Auto type-inferencing occurs in a declaration where a variable's type is inferred from its initialization ex\-pression type.
+Auto type-inferencing occurs in a declaration where a variable's type is inferred from its initialization expression type.
 \begin{quote2}
 \begin{tabular}{@{}l@{\hspace{3em}}ll@{}}
 …
 \begin{itemize}
 \item
 preventing having to determine or write long generic types,
+preventing having to determine or write out long generic types,
 \item
 ensure secondary variables, related to a primary variable, always have the same type.
 …
 \Indexc{gcc} provides ©typeof© to declare a secondary variable from a primary variable.
 \CFA also relies heavily on the specification of the left-hand side of assignment for type inferencing, so in many cases it is crucial to specify the type of the left-hand side to select the correct type of the right-hand expression.
 Only for overloaded routines \emph{with the same return type} is variable type-inferencing possible.
+Only for overloaded routines with the same return type is variable type-inferencing possible.
 Finally, ©auto© presents the programming problem of tracking down a type when the type is actually needed.
 For example, given
 …
 There is also the conundrum in type inferencing of when to \emph{\Index{brand}} a type.
 That is, when is the type of the variable more important than the type of its initialization expression.
 For example, if a change is made in an initialization expression, it can cause significant cascading type changes and/or errors.
 At some point, a variable type needs to remain constant and the expression to be in error when it changes.
+For example, if a change is made in an initialization expression, it can cause hundreds or thousands of cascading type changes and/or errors.
+At some point, a programmer wants the type of the variable to remain constant and the expression to be in error when it changes.
 Given ©typedef© and ©typeof© in \CFA, and the strong need to use the type of left-hand side in inferencing, auto type-inferencing is not supported at this time.
 …
+        }
 \end{cfa}
+\end{comment}
+\subsection{Memory Management}
+\subsubsection{Manual Memory Management}
+Using malloc and free to dynamically allocate memory exposes several potential, and common, errors.
+First, malloc breaks type safety because it returns a pointer to void.
+There is no relationship between the type that the returned pointer is cast to, and the amount of memory allocated.
+This problem is solved with a type-safe malloc.
+Do.s type-safe malloc does not take any arguments for size.
+Instead, it infers the type based on the return value, and then allocates space for the inferred type.
+\begin{cfa}
+float *f = malloc(); // allocates the size of a float
+struct S {
+        int i, j, k;
+};
+struct S *s = malloc(); // allocates the size of a struct S
+\end{cfa}
+In addition to the improved malloc, \CFA also provides a technique for combining allocation and initialization into one step, using the new function.
+For all constructors defined for a given type (see Operator Overloading), a corresponding call to new can be used to allocate and construct that type.
+\begin{cfa}
+type Complex = struct {
+        float real;
+        float imag;
+};
+// default constructor
+void ?{}(Complex &c) {
+        c.real = 0.0;
+        c.imag = 0.0;
+}
+// 2 parameter constructor
+void ?{}(Complex &c, float real, float imag) {
+        c.real = real;
+        c.imag = imag;
+}
+int main() {
+        Complex c1; // No constructor is called
+        Complex c2{}; // Default constructor called
+        Complex c3{1.0, -1.0}; // 2 parameter constructor is called
+        Complex *p1 = malloc(); // allocate
+        Complex *p2 = new(); // allocate + default constructor
+        Complex *p3 = new(0.5, 1.0); // allocate + 2 param constructor
+}
+\end{cfa}
+\subsubsection{Automatic Memory Management}
+\CFA may also support automatic memory management to further improve safety.
+If the compiler can insert all of the code needed to manage dynamically allocated memory (automatic reference counting), then developers can avoid problems with dangling pointers, double frees, memory leaks, etc.
+This feature requires further investigation.
+\CFA will not have a garbage collector, but might use some kind of region-based memory management.
+\begin{comment}
+\subsection{Unsafe C Constructs}
+C programmers are able to access all of the low-level tricks that are sometimes needed for close-to-the-hardware programming.
+Some of these practices however are often error-prone and difficult to read and maintain.
+Since \CFA is designed to be safer than C, such constructs are disallowed in \CFA code.
+If a programmer wants to use one of these unsafe C constructs, the unsafe code must be contained in a C linkage block (see Interoperability), which will be compiled like C code.
+This block means that the user is telling the tools, .I know this is unsafe, but I.m going to do it anyway..
+The exact set of unsafe C constructs that will be disallowed in \CFA has not yet been decided, but is sure to include pointer arithmetic, pointer casting, etc.
+Once the full set is decided, the rules will be listed here.
 \end{comment}
 …
 \label{f:SimpleTasks}
 \end{figure}
+\begin{comment}
+\begin{cfa}
+type Adder = task {
+        int *row;
+        int size;
+        int &subtotal;
+}
+\end{cfa}
+A task may define a constructor, which will be called upon allocation and run on the caller.s thread.
+A destructor may also be defined, which is called at deallocation (when a dynamic object is deleted or when a local object goes out of scope).
+After a task is allocated and initialized, its thread is spawned implicitly and begins executing in its function call method.
+All tasks must define this function call method, with a void return value and no additional parameters, or the compiler will report an error.
+Below are example functions for the above Adder task, and its usage to sum up a matrix on multiple threads.
+(Note that this example is designed to display the syntax and functionality, not the best method to solve this problem)
+\begin{cfa}
+void ?{}(Adder &a, int r[], int s, int &st) { // constructor
+        a.row = r;
+        a.size = s;
+        a.subtotal = st;
+}
+// implicitly spawn thread and begin execution here
+void ?()(Adder &a) {
+        int c;
+        subtotal = 0;
+        for (c=0; c<a.size; ++c) {
+        subtotal += row[c];
+        }
+}
+int main() {
+        const int rows = 100, cols = 1000000;
+        int matrix[rows][cols];
+        int subtotals[rows];
+        int total = 0;
+        int r;
+        { // create a new scope here for our adders
+        Adder adders[rows];
+        // read in the matrix
+        ...
+        for (r=0; r<rows; ++r) {
+        // tasks are initialized on this thread
+        Adders[r] = {matrix[r], cols, subtotals[r]};
+        Adders[r](); // spawn thread and begin execution
+        }
+        } // adders go out of scope; block here until they all finish
+        total += subtotals[r];
+        printf(.total is %d\n., total);
+}
+\end{cfa}
+\subsection{Cooperative Scheduling}
+Tasks in \CFA are cooperatively scheduled, meaning that a task will not be interrupted by another task, except at specific yield points.
+In Listing 31, there are no yield points, so each task runs to completion with no interruptions.
+Places where a task could yield include waiting for a lock (explicitly or implicitly), waiting for I/O, or waiting for a specific function (or one of a set of functions) to be called.
+This last option is introduced with the yield function. yield is used to indicate that this task should yield its thread until the specified function is called.
+For example, the code below defines a monitor that maintains a generic list.
+When a task tries to pop from the list, but it is empty, the task should yield until another task puts something into the list, with the push function.
+Similarly, when a task tries to push something onto the list, but it is full, it will yield until another task frees some space with the pop function.
+\begin{cfa}
+// type T is used as a generic type for all definitions inside
+// the curly brackets
+generic(type T) {
+        type Channel = monitor {
+        List(T) list; // list is a simple generic list type
+        };
+        T pop(mutex &Channel(T) ch) {
+        if (ch.list.empty()) {
+        // yield until push is called for this channel
+        yield(push);
+        }
+        return ch.list.pop();
+        }
+        void push(mutex &Channel(T)ch, T val) {
+        if (ch.list.full()) {
+        // yield until pop is called for this channel
+        yield(pop);
+        }
+        ch.list.push(val);
+        }
+}
+\end{cfa}
+A task can also yield indefinitely by calling yield with no arguments.
+This will tell the scheduler to yield this task until it is resumed by some other task.
+A task can resume another task by using its functional call operator.
+The code below shows a simple ping-pong example, where two tasks yield back and forth to each other using these methods.
+\begin{cfa}
+type Ping = task {
+        Pong *partner;
+};
+void ?{}(Ping &p, Pong *partner = 0) {
+        p.partner = partner;
+}
+void ?()(Ping &p) {
+        for(;;) { // loop forever
+        printf(.ping\n.);
+        partner(); // resumes the partner task
+        yield(); // yields this task
+        }
+}
+type Pong = task {
+        Ping *partner;
+};
+void ?{}(Pong &p, Ping *partner = 0) {
+        p.partner = partner;
+}
+void ?()(Pong &p) {
+        for(;;) { // loop forever
+        yield(); // yields this task
+        printf(.pong/n.);
+        partner(); // resumes the partner task
+        }
+}
+void main() {
+        Ping ping; // allocate ping
+        Pong pong{ping}; // allocate, initialize, and start pong
+        Ping{pong}; // initialize and start ping
+}
+\end{cfa}
+The same functionality can be accomplished by providing functions to be called by the partner task.
+\begin{cfa}
+type Pingpong = task {
+        String msg;
+        Pingpong *partner;
+};
+void ?{}(Pingpong &p, String msg, Pingpong *partner = 0) {
+        p.msg = msg;
+        p.partner = partner;
+}
+void ?()(Pingpong &p) {
+        for(;;) {
+        yield(go);
+        }
+}
+void go(Pingpong &p) {
+        print(.%(p.msg)\n.);
+        go(p.partner);
+}
+void main() {
+        Pingpong ping = {.ping.};
+        Pingpong pong = {.pong., ping};
+        ping.partner = pong;
+        go(ping);
+}
+\end{cfa}
+\end{comment}
 …
 \section{Language Comparisons}
+\section{Comparison with Other Languages}
 \CFA is one of many languages that attempts to improve upon C.
 …
+\section{C Incompatibles}
+\section{\texorpdfstring{\CFA Keywords}{Cforall Keywords}}
+\label{s:CFAKeywords}
+\CFA introduces the following new keywords.
+\begin{quote2}
+\begin{tabular}{lllll}
+\begin{tabular}{@{}l@{}}
+©_At©                   \\
+©catch©                 \\
+©catchResume©   \\
+©choose©                \\
+©coroutine©             \\
+\end{tabular}
+&
+\begin{tabular}{@{}l@{}}
+©disable©               \\
+©dtype©                 \\
+©enable©                \\
+©fallthrough©   \\
+©fallthru©              \\
+\end{tabular}
+&
+\begin{tabular}{@{}l@{}}
+©finally©               \\
+©forall©                \\
+©ftype©                 \\
+©lvalue©                \\
+©monitor©               \\
+\end{tabular}
+&
+\begin{tabular}{@{}l@{}}
+©mutex©                 \\
+©one_t©                 \\
+©otype©                 \\
+©throw©                 \\
+©throwResume©   \\
+\end{tabular}
+&
+\begin{tabular}{@{}l@{}}
+©trait©                 \\
+©try©                   \\
+©ttype©                 \\
+©zero_t©                \\
+                                \\
+\end{tabular}
+\end{tabular}
+\end{quote2}
+\section{Incompatible}
 The following incompatibles exist between \CFA and C, and are similar to Annex C for \CC~\cite{C++14}.
 …
 g( p1, p2 ) int p1, p2;                 §\C{// int g( int p1, int p2 );}§
 \end{cfa}
 \CFA continues to support K\&R routine definitions:
+\CFA supports K\&R routine definitions:
 \begin{cfa}
 f( a, b, c )                                    §\C{// default int return}§
 …
 struct X { int i; struct X *next; };
 static struct X a;                              §\C{// forward definition}§
 static struct X b = { 0, ®&a® };§\C{// forward reference, valid in C, invalid in \CFA}§
+static struct X b = { 0, ®&a® };        §\C{// forward reference, valid in C, invalid in \CFA}§
 static struct X a = { 1, &b };  §\C{// definition}§
 \end{cfa}
 …
 enum ®Colour® { R, G, B, Y, C, M };
 struct Person {
         enum ®Colour® { R, G, B };      §\C[7cm]{// nested type}§
+        enum ®Colour® { R, G, B };      §\C{// nested type}§
         struct Face {                           §\C{// nested type}§
                 ®Colour® Eyes, Hair;    §\C{// type defined outside (1 level)}§
 …
 };
 ®Colour® c = R;                                 §\C{// type/enum defined same level}§
 Person®.Colour® pc = Person®.®R;§\C{// type/enum defined inside}§
 Person®.®Face pretty;                   §\C{// type defined inside}\CRT§
+Person®.Colour® pc = Person®.®R;        §\C{// type/enum defined inside}§
+Person®.®Face pretty;                   §\C{// type defined inside}§
 \end{cfa}
 In C, the name of the nested types belongs to the same scope as the name of the outermost enclosing structure, \ie the nested types are hoisted to the scope of the outer-most type, which is not useful and confusing.
 …
 \item
 \begin{description}
-\item[Change:] remove implicit conversion of ©void *© to or from any ©T *© pointer:
-\begin{cfa}
-void foo() {
-        int * b = malloc( sizeof(int) );        §\C{// implicitly convert void * to int *}§
-        char * c = b;                           §\C{// implicitly convert int * to void *, and then void * to char *}§
+}
-\end{cfa}
-\item[Rationale:] increase type safety
-\item[Effect on original feature:] deletion of semantically well-defined feature.
-\item[Difficulty of converting:] requires adding a cast (see \VRef{s:StorageManagement} for better alternatives):
-\begin{cfa}
-        int * b = (int *)malloc( sizeof(int) );
-        char * c = (char *)b;
-\end{cfa}
-\item[How widely used:] Significant.
-Some C translators already give a warning if the cast is not used.
-\end{description}
-\item
-\begin{description}
-\item[Change:] Types must be declared in declarations, not in expressions
-In C, a sizeof expression or cast expression may create a new type. For example,
-\begin{cfa}
-p = (void*)(struct x {int i;} *)0;
-\end{cfa}
-declares a new type, struct x .
-\item[Rationale:] This prohibition helps to clarify the location of declarations in the source code.
-\item[Effect on original feature:] Deletion of a semantically welldefined feature.
-\item[Difficulty of converting:] Syntactic transformation.
-\item[How widely used:] Seldom.
-\end{description}
-\item
-\begin{description}
 \item[Change:] comma expression is disallowed as subscript
 \item[Rationale:] safety issue to prevent subscripting error for multidimensional arrays: ©x[i,j]© instead of ©x[i][j]©, and this syntactic form then taken by \CFA for new style arrays.
 \item[Effect on original feature:] change to semantics of well-defined feature.
 \item[Difficulty of converting:] semantic transformation of ©x[i,j]© to ©x[(i,j)]©
 \item[How widely used:] Seldom.
+\item[How widely used:] seldom.
 \end{description}
 \end{enumerate}
-\section{\texorpdfstring{\CFA Keywords}{Cforall Keywords}}
-\label{s:CFAKeywords}
-\CFA introduces the following new keywords.
-\begin{quote2}
-\input{../refrat/keywords}
-\end{quote2}
 \section{Standard Headers}
 \label{s:StandardHeaders}
 …
 \Celeven prescribes the following standard header-files~\cite[\S~7.1.2]{C11} and \CFA adds to this list:
 \begin{quote2}
+\begin{tabular}{@{}llllll|l@{}}
+\multicolumn{6}{c|}{C11} & \multicolumn{1}{c}{\CFA}             \\
+\lstset{deletekeywords={float}}
+\begin{tabular}{@{}llll|l@{}}
+\multicolumn{4}{c|}{C11} & \multicolumn{1}{c}{\CFA}             \\
 \hline
 \begin{tabular}{@{}l@{}}
 …
 \Indexc{errno.h}                \\
 \Indexc{fenv.h}                 \\
+\Indexc{float.h}                \\
+\Indexc{inttypes.h}             \\
+\Indexc{iso646.h}               \\
 \end{tabular}
+&
 \begin{tabular}{@{}l@{}}
-\Indexc[deletekeywords=float]{float.h} \\
-\Indexc{inttypes.h}             \\
-\Indexc{iso646.h}               \\
 \Indexc{limits.h}               \\
 \Indexc{locale.h}               \\
-\end{tabular}
+&
-\begin{tabular}{@{}l@{}}
 \Indexc{math.h}                 \\
 \Indexc{setjmp.h}               \\
 …
 \Indexc{stdalign.h}             \\
 \Indexc{stdarg.h}               \\
+\Indexc{stdatomic.h}    \\
 \end{tabular}
+&
 \begin{tabular}{@{}l@{}}
-\Indexc{stdatomic.h}    \\
 \Indexc{stdbool.h}              \\
 \Indexc{stddef.h}               \\
 \Indexc{stdint.h}               \\
 \Indexc{stdio.h}                \\
-\end{tabular}
+&
-\begin{tabular}{@{}l@{}}
 \Indexc{stdlib.h}               \\
 \Indexc{stdnoreturn.h}  \\
 \Indexc{string.h}               \\
 \Indexc{tgmath.h}               \\
-\Indexc{threads.h}              \\
 \end{tabular}
+&
 \begin{tabular}{@{}l@{}}
+\Indexc{threads.h}              \\
 \Indexc{time.h}                 \\
 \Indexc{uchar.h}                \\
 …
 \Indexc{wctype.h}               \\
                                                 \\
+                                                \\
+                                                \\
 \end{tabular}
+&
 \begin{tabular}{@{}l@{}}
+\Indexc{unistd.h}               \\
 \Indexc{gmp.h}                  \\
+\Indexc{malloc.h}               \\
+\Indexc{unistd.h}               \\
+                                                \\
+                                                \\
+                                                \\
+                                                \\
                                                 \\
                                                 \\
 …
 hence, names in these include files are not mangled\index{mangling!name} (see~\VRef{s:Interoperability}).
 All other C header files must be explicitly wrapped in ©extern "C"© to prevent name mangling.
 For \Index*[C++]{\CC{}}, the name-mangling issue is often handled internally in many C header-files through checks for preprocessor variable ©__cplusplus©, which adds appropriate ©extern "C"© qualifiers.
+For \Index*[C++]{\CC{}}, the name-mangling issue is handled implicitly because most C header-files are augmented with checks for preprocessor variable ©__cplusplus©, which adds appropriate ©extern "C"© qualifiers.
 …
 \subsection{Storage Management}
-\label{s:StorageManagement}
 The storage-management routines extend their C equivalents by overloading, alternate names, providing shallow type-safety, and removing the need to specify the allocation size for non-array types.
 …
 The table shows allocation routines supporting different combinations of storage-management capabilities:
 \begin{center}
 \begin{tabular}{@{}r|r|l|l|l|l@{}}
 \multicolumn{1}{c}{}&           & \multicolumn{1}{c|}{fill}     & resize        & alignment     & array \\
+\begin{tabular}{@{}lr|l|l|l|l@{}}
+                &                                       & \multicolumn{1}{c|}{fill}     & resize        & alignment     & array \\
 \hline
 C               & ©malloc©                      & no                    & no            & no            & no    \\
 …
                 & ©memalign©            & no                    & no            & yes           & no    \\
                 & ©posix_memalign©      & no                    & no            & yes           & no    \\
-\hline
 C11             & ©aligned_alloc©       & no                    & no            & yes           & no    \\
-\hline
 \CFA    & ©alloc©                       & no/copy/yes   & no/yes        & no            & yes   \\
                 & ©align_alloc©         & no/yes                & no            & yes           & yes   \\
 …
 long double remainder( long double, long double );
+float remquo( float, float, int * );§\indexc{remquo}§
+[ int, float ] remquo( float, float );§\indexc{remquo}§
+float remquo( float, float, int * );
+[ int, double ] remquo( double, double );
 double remquo( double, double, int * );
+[ int, long double ] remquo( long double, long double );
 long double remquo( long double, long double, int * );
+[ int, float ] remquo( float, float );
+[ int, double ] remquo( double, double );
+[ int, long double ] remquo( long double, long double );
+float div( float, float, int * );§\indexc{div}§ §\C{// alternative name for remquo}§
+[ int, float ] div( float, float );                                             // alternative name for remquo
+float div( float, float, int * );§\indexc{div}§
+[ int, double ] div( double, double );
 double div( double, double, int * );
+[ int, long double ] div( long double, long double );
 long double div( long double, long double, int * );
-[ int, float ] div( float, float );
-[ int, double ] div( double, double );
-[ int, long double ] div( long double, long double );
 float fma( float, float, float );§\indexc{fma}§
 …
 double exp2( double );
 long double exp2( long double );
 // float _Complex exp2( float _Complex );
 // double _Complex exp2( double _Complex );
 // long double _Complex exp2( long double _Complex );
+float _Complex exp2( float _Complex );
+double _Complex exp2( double _Complex );
+long double _Complex exp2( long double _Complex );
 float expm1( float );§\indexc{expm1}§
 double expm1( double );
 long double expm1( long double );
+float log( float );§\indexc{log}§
+double log( double );
+long double log( long double );
+float _Complex log( float _Complex );
+double _Complex log( double _Complex );
+long double _Complex log( long double _Complex );
+float log2( float );§\indexc{log2}§
+double log2( double );
+long double log2( long double );
+float _Complex log2( float _Complex );
+double _Complex log2( double _Complex );
+long double _Complex log2( long double _Complex );
+float log10( float );§\indexc{log10}§
+double log10( double );
+long double log10( long double );
+float _Complex log10( float _Complex );
+double _Complex log10( double _Complex );
+long double _Complex log10( long double _Complex );
+float log1p( float );§\indexc{log1p}§
+double log1p( double );
+long double log1p( long double );
+int ilogb( float );§\indexc{ilogb}§
+int ilogb( double );
+int ilogb( long double );
+float logb( float );§\indexc{logb}§
+double logb( double );
+long double logb( long double );
+\end{cfa}
+\subsection{Power}
+\leavevmode
+\begin{cfa}[aboveskip=0pt,belowskip=0pt]
+float sqrt( float );§\indexc{sqrt}§
+double sqrt( double );
+long double sqrt( long double );
+float _Complex sqrt( float _Complex );
+double _Complex sqrt( double _Complex );
+long double _Complex sqrt( long double _Complex );
+float cbrt( float );§\indexc{cbrt}§
+double cbrt( double );
+long double cbrt( long double );
+float hypot( float, float );§\indexc{hypot}§
+double hypot( double, double );
+long double hypot( long double, long double );
 float pow( float, float );§\indexc{pow}§
 …
 double _Complex pow( double _Complex, double _Complex );
 long double _Complex pow( long double _Complex, long double _Complex );
-\end{cfa}
-\subsection{Logarithm}
-\leavevmode
-\begin{cfa}[aboveskip=0pt,belowskip=0pt]
-float log( float );§\indexc{log}§
-double log( double );
-long double log( long double );
-float _Complex log( float _Complex );
-double _Complex log( double _Complex );
-long double _Complex log( long double _Complex );
-float log2( float );§\indexc{log2}§
-double log2( double );
-long double log2( long double );
-// float _Complex log2( float _Complex );
-// double _Complex log2( double _Complex );
-// long double _Complex log2( long double _Complex );
-float log10( float );§\indexc{log10}§
-double log10( double );
-long double log10( long double );
-// float _Complex log10( float _Complex );
-// double _Complex log10( double _Complex );
-// long double _Complex log10( long double _Complex );
-float log1p( float );§\indexc{log1p}§
-double log1p( double );
-long double log1p( long double );
-int ilogb( float );§\indexc{ilogb}§
-int ilogb( double );
-int ilogb( long double );
-float logb( float );§\indexc{logb}§
-double logb( double );
-long double logb( long double );
-float sqrt( float );§\indexc{sqrt}§
-double sqrt( double );
-long double sqrt( long double );
-float _Complex sqrt( float _Complex );
-double _Complex sqrt( double _Complex );
-long double _Complex sqrt( long double _Complex );
-float cbrt( float );§\indexc{cbrt}§
-double cbrt( double );
-long double cbrt( long double );
-float hypot( float, float );§\indexc{hypot}§
-double hypot( double, double );
-long double hypot( long double, long double );
 \end{cfa}
 …
 long double atan2( long double, long double );
 float atan( float, float );                                     §\C{// alternative name for atan2}§
+float atan( float, float );                                                             // alternative name for atan2
 double atan( double, double );§\indexc{atan}§
 long double atan( long double, long double );
 …
 \begin{cfa}
 void ?{}( Int * this );                                 §\C{// constructor/destructor}§
+void ?{}( Int * this );                                 §\C{// constructor}§
 void ?{}( Int * this, Int init );
 void ?{}( Int * this, zero_t );
 …
 // implementation
 struct Rational {§\indexc{Rational}§
         long int numerator, denominator;        §\C{// invariant: denominator > 0}§
+        long int numerator, denominator;                                        // invariant: denominator > 0
 }; // Rational

doc/working/resolver_design.md

-              r0720e049
+              r3d4b23fa
 ## Conversion Costs ##
 Each possible resolution of an expression has a _cost_ tuple consisting of
+the following components:
+. _unsafe_ conversion cost: summed degree of unsafe conversions; unlike CFA03, this is not a simple count of conversions (for symmetry with the safe conversions)
+. _polymorphic unifications_: count of parameters and return values bound to some polymorphic type for boxing
+. _type variables_: number of polymorphic type variables bound
+. negated _type specializations_: Each type assertion specializes the polymorphism, thus decreasing the cost; nested polymorphic types (e.g. `T*`) are also counted as specializations
+. _safe_ conversions: summed degree of safe conversions
+. _qualifier_ conversions: summed degree of qualifier and reference conversions
+the following components: _unsafe_ conversion cost, _polymorphic_
+specialization cost, _safe_ conversion cost, a count of _explicit_
+conversions, and _qualifier_ conversion cost.
 These components are lexically-ordered and can be summed element-wise;
 summation starts at `(0, 0, 0, 0, 0)`.
-**TODO** update below for consistency with this
 ### Lvalue and Qualifier Conversions ###

src/CodeGen/CodeGenerator.cc

-              r0720e049
+              r3d4b23fa
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Andrew Beach
 // Last Modified On : Tus Jul 25 15:29:00 2017
 // Update Count     : 486
+// Last Modified On : Thu Jun  8 16:00:00 2017
+// Update Count     : 485
 //
-#include "CodeGenerator.h"
 #include <cassert>                   // for assert, assertf
 #include <list>                      // for _List_iterator, list, list<>::it...
+#include "CodeGenerator.h"
 #include "Common/SemanticError.h"    // for SemanticError
 #include "Common/UniqueName.h"       // for UniqueName
 …
+        }
-        void CodeGenerator::visit( VirtualCastExpr * castExpr ) {
-                assertf( ! genC, "VirtualCastExpr should not reach code generation." );
-                extension( castExpr );
-                output << "(virtual ";
-                castExpr->get_arg()->accept( *this );
-                output << ")";
+        }
         void CodeGenerator::visit( UntypedMemberExpr * memberExpr ) {
                 assertf( ! genC, "UntypedMemberExpr should not reach code generation." );

src/CodeGen/CodeGenerator.h

-              r0720e049
+              r3d4b23fa
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Andrew Beach
 // Last Modified On : Tus Jul 25 25:30:00 2017
 // Update Count     : 54
+// Last Modified On : Thu Jun  8 15:48:00 2017
+// Update Count     : 52
 //
+#pragma once
+#ifndef CODEGENV_H
+#define CODEGENV_H
 #include <list>                   // for list
 …
                 virtual void visit( AddressExpr *addressExpr );
                 virtual void visit( CastExpr *castExpr );
-                virtual void visit( VirtualCastExpr *castExpr );
                 virtual void visit( UntypedMemberExpr *memberExpr );
                 virtual void visit( MemberExpr *memberExpr );
 …
 } // namespace CodeGen
+#endif // CODEGENV_H
 // Local Variables: //
 // tab-width: 4 //

src/CodeGen/FixMain.h

-              r0720e049
+              r3d4b23fa
 // Author           : Thierry Delisle
 // Created On       : Thr Jan 12 14:11:09 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Jul 21 22:16:59 2017
 // Update Count     : 1
+// Last Modified By :
+// Last Modified On :
+// Update Count     : 0
 //
+#pragma once
+#ifndef FIXMAIN_H
+#define FIXMAIN_H
 #include <iosfwd>
 …
         };
 };
+#endif //FIXMAIN_H

src/CodeGen/FixNames.h

-              r0720e049
+              r3d4b23fa
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Jul 21 22:17:33 2017
 // Update Count     : 3
+// Last Modified On : Mon May 18 23:37:32 2015
+// Update Count     : 2
 //
+#pragma once
+#ifndef FIXNAMES_H
+#define FIXNAMES_H
 #include <list>  // for list
 …
 } // namespace CodeGen
+#endif // FIXNAMES_H
 // Local Variables: //
 // tab-width: 4 //

src/CodeGen/GenType.cc

-              r0720e049
+              r3d4b23fa
 // Update Count     : 22
 //
-#include "GenType.h"
 #include <cassert>                // for assert, assertf
 …
 #include "CodeGenerator.h"        // for CodeGenerator
+#include "GenType.h"
 #include "SynTree/Declaration.h"  // for DeclarationWithType
 #include "SynTree/Expression.h"   // for Expression

src/CodeGen/GenType.h

-              r0720e049
+              r3d4b23fa
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Jul 21 22:17:23 2017
 // Update Count     : 2
+// Last Modified On : Mon May 18 23:38:53 2015
+// Update Count     : 1
 //
+#pragma once
+#ifndef _GENTYPE_H
+#define _GENTYPE_H
 #include <string>  // for string
 …
 } // namespace CodeGen
+#endif // _GENTYPE_H
 // Local Variables: //
 // tab-width: 4 //

src/CodeGen/Generate.cc

-              r0720e049
+              r3d4b23fa
 // Update Count     : 6
 //
-#include "Generate.h"
 #include <iostream>                  // for ostream, endl, operator<<
 …
 #include "CodeGenerator.h"           // for CodeGenerator, doSemicolon, oper...
 #include "GenType.h"                 // for genPrettyType
+#include "Generate.h"
 #include "Parser/LinkageSpec.h"      // for isBuiltin, isGeneratable
 #include "SynTree/BaseSyntaxNode.h"  // for BaseSyntaxNode

src/CodeGen/Generate.h

-              r0720e049
+              r3d4b23fa
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Jul 21 22:16:35 2017
 // Update Count     : 2
+// Last Modified On : Mon May 18 23:39:51 2015
+// Update Count     : 1
 //
+#pragma once
+#ifndef GENERATE_H
+#define GENERATE_H
 #include <iostream>  // for ostream
 …
 } // namespace CodeGen
+#endif // GENERATE_H
 // Local Variables: //
 // tab-width: 4 //

src/CodeGen/OperatorTable.cc

-              r0720e049
+              r3d4b23fa
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 15 17:12:22 2017
 // Update Count     : 15
+// Last Modified On : Tue Dec 13 14:33:05 2016
+// Update Count     : 10
 //
 …
                         {       "++?",          "++",   "_operator_preincr",                    OT_PREFIXASSIGN         },
                         {       "--?",          "--",   "_operator_predecr",                    OT_PREFIXASSIGN         },
-                        {       "?\\?",         "\\",   "_operator_exponential",                OT_INFIX                        },
                         {       "?*?",          "*",    "_operator_multiply",                   OT_INFIX                        },
                         {       "?/?",          "/",    "_operator_divide",                             OT_INFIX                        },
 …
                         {       "?|?",          "|",    "_operator_bitor",                              OT_INFIX                        },
                         {       "?=?",          "=",    "_operator_assign",                             OT_INFIXASSIGN          },
-                        {       "?\\=?",        "\\=",  "_operator_expassign",                  OT_INFIXASSIGN          },
                         {       "?*=?",         "*=",   "_operator_multassign",                 OT_INFIXASSIGN          },
                         {       "?/=?",         "/=",   "_operator_divassign",                  OT_INFIXASSIGN          },

src/CodeGen/OperatorTable.h

-              r0720e049
+              r3d4b23fa
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Jul 21 22:17:11 2017
 // Update Count     : 6
+// Last Modified By : Rob Schluntz
+// Last Modified On : Wed Jun 24 16:17:57 2015
+// Update Count     : 5
 //
+#pragma once
+#ifndef _OPERATORTABLE_H
+#define _OPERATORTABLE_H
 #include <string>
 …
 } // namespace CodeGen
+#endif // _OPERATORTABLE_H
 // Local Variables: //
 // tab-width: 4 //

src/CodeTools/DeclStats.h

-              r0720e049
+              r3d4b23fa
 // Author           : Aaron Moss
 // Created On       : Wed Jan 31 16:40:00 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Jul 21 22:17:56 2017
 // Update Count     : 2
+// Last Modified By : Aaron Moss
+// Last Modified On : Wed Jan 31 16:40:00 2016
+// Update Count     : 1
 //
+#pragma once
+#ifndef DECLSTATS_H
+#define DECLSTATS_H
 #include <list>  // for list
 …
 }  // namespace CodeTools
+#endif // DECLSTATS_H
 // Local Variables: //
 // tab-width: 4 //

src/CodeTools/TrackLoc.cc

-              r0720e049
+              r3d4b23fa
 #include "TrackLoc.h"
+#include <cstdlib>                   // for exit, EXIT_FAILURE
+#include <iostream>                  // for operator<<, ostream, basic_ostream
+#include <stack>                     // for stack
+#include <string>                    // for operator<<, string
+#include <typeindex>                 // for type_index
+#include <cstdlib>                    // for size_t, exit, EXIT_FAILURE
+#include <iostream>                   // for operator<<, ostream, basic_ostream
+#include <iterator>                   // for back_inserter, inserter
+#include <stack>                      // for stack
+#include <string>                     // for operator<<, string
+#include <typeindex>                  // for type_index
+#include "Common/PassVisitor.h"      // for PassVisitor
+#include "Common/utility.h"          // for CodeLocation
+#include "SynTree/BaseSyntaxNode.h"  // for BaseSyntaxNode
+#include "Common/PassVisitor.h"       // for PassVisitor
+#include "Common/PassVisitor.impl.h"  // for acceptAll
+#include "Common/SemanticError.h"     // for SemanticError
+#include "Common/utility.h"           // for CodeLocation
+#include "SynTree/BaseSyntaxNode.h"   // for BaseSyntaxNode
+#include "SynTree/Mutator.h"          // for mutateAll
+#include "SynTree/Visitor.h"          // for acceptAll
 class Declaration;
 …
                 std::stack< CodeLocation * > parents;
         public:
                 LocationPrinter(size_t printLevel) :
+                LocationPrinter(size_t printLevel) :
                         printLevel(printLevel), lastNode(nullptr)
                 {}
 …
                                 if ( !parents.empty() ) {
                                         node->location = *parents.top();
+                                }
+                                }
                                 else if (nullptr != lastNode) {
                                         node->location = *lastNode;
+                                }
+                                }
                                 else {
                                         std::cerr << "Top level node has no CodeLocation " << name << std::endl;

src/CodeTools/TrackLoc.h

-              r0720e049
+              r3d4b23fa
 // Author           : Andrew Beach
 // Created On       : Tues May 2 15:40:00 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Jul 21 22:17:44 2017
 // Update Count     : 1
+// Last Modified By : Andrew Beach
+// Last Modified On : Wed May 3 14:42:00 2017
+// Update Count     : 0
 //
+#pragma once
+#ifndef TRACKLOC_H
+#define TRACKLOC_H
 #include <cstddef>   // for size_t
 …
 }  // namespace CodeTools
+#endif // TRACKLOC_H
 // Local Variables: //
 // tab-width: 4 //

src/Common/CompilerError.h

-              r0720e049
+              r3d4b23fa
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Jul 21 22:18:07 2017
 // Update Count     : 4
+// Last Modified On : Thu Aug 18 23:41:30 2016
+// Update Count     : 3
 //
+#pragma once
+#ifndef COMPILER_ERROR_H
+#define COMPILER_ERROR_H
 #include <string>
 …
 };
+#endif // COMPILER_ERROR_H
 // Local Variables: //
 // tab-width: 4 //

src/Common/PassVisitor.h

-              r0720e049
+              r3d4b23fa
         virtual void visit( NameExpr *nameExpr ) override final;
         virtual void visit( CastExpr *castExpr ) override final;
-        virtual void visit( VirtualCastExpr *castExpr ) override final;
         virtual void visit( AddressExpr *addressExpr ) override final;
         virtual void visit( LabelAddressExpr *labAddressExpr ) override final;
 …
         virtual Expression* mutate( LabelAddressExpr *labAddressExpr ) override final;
         virtual Expression* mutate( CastExpr *castExpr ) override final;
-        virtual Expression* mutate( VirtualCastExpr *castExpr ) override final;
         virtual Expression* mutate( UntypedMemberExpr *memberExpr ) override final;
         virtual Expression* mutate( MemberExpr *memberExpr ) override final;

src/Common/PassVisitor.impl.h

-              r0720e049
+              r3d4b23fa
 #pragma once
-// IWYU pragma: private, include "PassVisitor.h"
 #define VISIT_START( node )                     \
 …
 template< typename pass_type >
-void PassVisitor< pass_type >::visit( VirtualCastExpr * node ) {
-        VISIT_BODY( node );
+}
-template< typename pass_type >
 void PassVisitor< pass_type >::visit( AddressExpr * node ) {
         VISIT_BODY( node );
 …
 template< typename pass_type >
-Expression * PassVisitor< pass_type >::mutate( VirtualCastExpr * node ) {
-        MUTATE_BODY( Expression, node );
+}
-template< typename pass_type >
 Expression * PassVisitor< pass_type >::mutate( UntypedMemberExpr * node ) {
         MUTATE_BODY( Expression, node );

src/Common/PassVisitor.proto.h

r0720e049	r3d4b23fa
1	1	#pragma once
2		~~// IWYU pragma: private, include "PassVisitor.h"~~
3	2
4	3	template<typename pass_type>

src/Common/ScopedMap.h

-              r0720e049
+              r3d4b23fa
 // Author           : Aaron B. Moss
 // Created On       : Wed Dec 2 11:37:00 2015
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Fri Jul 21 22:18:24 2017
+// Update Count     : 2
+//
+#pragma once
+// Last Modified By : Aaron B. Moss
+// Last Modified On : Wed Dec 2 11:37:00 2015
+// Update Count     : 1
+//
+#ifndef _SCOPEDMAP_H
+#define _SCOPEDMAP_H
 #include <cassert>
 …
 };
+#endif // _SCOPEDMAP_H
 // Local Variables: //
 // tab-width: 4 //

src/Common/SemanticError.h

-              r0720e049
+              r3d4b23fa
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Jul 21 22:18:59 2017
 // Update Count     : 6
+// Last Modified On : Sat Sep 24 15:13:42 2016
+// Update Count     : 5
 //
+#pragma once
+#ifndef SEMANTICERROR_H
+#define SEMANTICERROR_H
 #include <exception>  // for exception
 …
+}
+#endif // SEMANTICERROR_H
 // Local Variables: //
 // tab-width: 4 //

src/Common/UnimplementedError.h

-              r0720e049
+              r3d4b23fa
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Jul 21 22:18:35 2017
 // Update Count     : 2
+// Last Modified On : Tue May 19 07:23:08 2015
+// Update Count     : 1
 //
+#pragma once
+#ifndef _UNIMPLEMENTEDERROR_H
+#define _UNIMPLEMENTEDERROR_H
 #include <string>
 …
 };
+#endif // _UNIMPLEMENTEDERROR_H
 // Local Variables: //
 // tab-width: 4 //

src/Common/UniqueName.h

-              r0720e049
+              r3d4b23fa
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Jul 21 22:18:45 2017
 // Update Count     : 2
+// Last Modified On : Tue May 19 07:24:20 2015
+// Update Count     : 1
 //
+#pragma once
+#ifndef UNIQUENAME_H
+#define UNIQUENAME_H
 #include <string>
 …
 };
+#endif // UNIQUENAME_H
 // Local Variables: //
 // tab-width: 4 //

src/Common/VectorMap.h

-              r0720e049
+              r3d4b23fa
 // file "LICENCE" distributed with Cforall.
 //
 // VectorMap.h --
+// ScopedMap.h --
 //
 // Author           : Aaron B. Moss
 // Created On       : Wed Feb  1 16:55:00 2017
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Fri Jul 21 22:19:29 2017
+// Update Count     : 2
+//
+#pragma once
+// Last Modified By : Aaron B. Moss
+// Last Modified On : Wed Feb  1 16:55:00 2017
+// Update Count     : 1
+//
+#ifndef _VECTORMAP_H
+#define _VECTORMAP_H
 #include <iterator>
 …
+}
+#endif // _VECTORMAP_H
 // Local Variables: //
 // tab-width: 4 //

src/Common/utility.h

-              r0720e049
+              r3d4b23fa
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Fri Jul 21 22:19:13 2017
+// Update Count     : 33
+//
+#pragma once
+// Last Modified By : Andrew Beach
+// Last Modified On : Fri May 5 11:03:00 2017
+// Update Count     : 32
+//
+#ifndef _UTILITY_H
+#define _UTILITY_H
 #include <cctype>
 …
+}
+#endif // _UTILITY_H
 // Local Variables: //
 // tab-width: 4 //

src/Concurrency/Keywords.cc

-              r0720e049
+              r3d4b23fa
+//                              -*- Mode: CPP -*-
 //
 // Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo
 …
 // Last Modified By :
 // Last Modified On :
 // Update Count     : 5
+// Update Count     : 3
 //
 …
+        }
 };
-// Local Variables: //
-// mode: c //
-// tab-width: 4 //
-// End: //

src/Concurrency/Keywords.h

-              r0720e049
+              r3d4b23fa
+//                              -*- Mode: CPP -*-
 //
 // Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo
 …
 // Last Modified By :
 // Last Modified On :
 // Update Count     : 1
+// Update Count     : 0
 //
+#pragma once
+#ifndef KEYWORDS_H
+#define KEYWORDS_H
 #include <list>  // for list
 …
 };
+// Local Variables: //
+// tab-width: 4 //
+// mode: c++ //
+// compile-command: "make install" //
+// End: //
+#endif //KEYWORDS_H

src/ControlStruct/ExceptTranslate.cc

-              r0720e049
+              r3d4b23fa
 // Created On       : Wed Jun 14 16:49:00 2017
 // Last Modified By : Andrew Beach
 // Last Modified On : Tus Aug  8 16:54:00 2017
 // Update Count     : 7
+// Last Modified On : Wed Jul 12 15:07:00 2017
+// Update Count     : 3
 //
 …
 #include "SynTree/Type.h"
 #include "SynTree/Attribute.h"
-#include "SynTree/VarExprReplacer.h"
 namespace ControlStruct {
+        // This (large) section could probably be moved out of the class
+        // and be static helpers instead.
+        // Type(Qualifiers &, false, std::list<Attribute *> &)
+        // void (*function)();
+        static FunctionType try_func_t(Type::Qualifiers(), false);
+        // void (*function)(int, exception);
+        static FunctionType catch_func_t(Type::Qualifiers(), false);
+        // int (*function)(exception);
+        static FunctionType match_func_t(Type::Qualifiers(), false);
+        // bool (*function)(exception);
+        static FunctionType handle_func_t(Type::Qualifiers(), false);
+        // void (*function)(__attribute__((unused)) void *);
+        static FunctionType finally_func_t(Type::Qualifiers(), false);
+        static void init_func_types() {
+                static bool init_complete = false;
+                if (init_complete) {
+                        return;
+                }
+                ObjectDecl index_obj(
+                        "__handler_index",
+                        Type::StorageClasses(),
+                        LinkageSpec::Cforall,
+                        /*bitfieldWidth*/ NULL,
+                        new BasicType( emptyQualifiers, BasicType::SignedInt ),
+                        /*init*/ NULL
+                        );
+                ObjectDecl exception_obj(
+                        "__exception_inst",
+                        Type::StorageClasses(),
+                        LinkageSpec::Cforall,
+                        /*bitfieldWidth*/ NULL,
+                        new PointerType(
+                                emptyQualifiers,
+                                new BasicType( emptyQualifiers, BasicType::SignedInt )
+                                ),
+                        /*init*/ NULL
+                        );
+                ObjectDecl bool_obj(
+                        "__ret_bool",
+                        Type::StorageClasses(),
+                        LinkageSpec::Cforall,
+                        /*bitfieldWidth*/ NULL,
+                        new BasicType(emptyQualifiers, BasicType::Bool),
+                        /*init*/ NULL
+                        );
+                ObjectDecl voidptr_obj(
+                        "__hook",
+                        Type::StorageClasses(),
+                        LinkageSpec::Cforall,
+                        NULL,
+                        new PointerType(
+                                emptyQualifiers,
+                                new VoidType(
+                                        emptyQualifiers
+                                        ),
+                                std::list<Attribute *>{new Attribute("unused")}
+                                ),
+                        NULL
+                        );
+                catch_func_t.get_parameters().push_back( index_obj.clone() );
+                catch_func_t.get_parameters().push_back( exception_obj.clone() );
+                match_func_t.get_returnVals().push_back( index_obj.clone() );
+                match_func_t.get_parameters().push_back( exception_obj.clone() );
+                handle_func_t.get_returnVals().push_back( bool_obj.clone() );
+                handle_func_t.get_parameters().push_back( exception_obj.clone() );
+                finally_func_t.get_parameters().push_back( voidptr_obj.clone() );
+                init_complete = true;
+        }
         // Buricratic Helpers (Not having to do with the paritular operation.)
 …
+        }
+        template<typename T>
+        void free_all( std::list<T *> &list ) {
+                typename std::list<T *>::iterator it;
+                for ( it = list.begin() ; it != list.end() ; ++it ) {
+                        delete *it;
+                }
+                list.clear();
+        }
         void appendDeclStmt( CompoundStmt * block, Declaration * item ) {
                 block->push_back(new DeclStmt(noLabels, item));
 …
+        }
+        class ExceptionMutatorCore : public WithGuards {
+                enum Context { NoHandler, TerHandler, ResHandler };
+                // Also need to handle goto, break & continue.
+                // They need to be cut off in a ResHandler, until we enter another
+                // loop, switch or the goto stays within the function.
+                Context cur_context;
+                // The current (innermost) termination handler exception declaration.
+                ObjectDecl * handler_except_decl;
+                // The built in types used in translation.
+                StructDecl * except_decl;
+                StructDecl * node_decl;
+                StructDecl * hook_decl;
+                // The many helper functions for code/syntree generation.
+                Statement * create_given_throw(
+                        const char * throwFunc, ThrowStmt * throwStmt );
+                Statement * create_terminate_throw( ThrowStmt * throwStmt );
+                Statement * create_terminate_rethrow( ThrowStmt * throwStmt );
+                Statement * create_resume_throw( ThrowStmt * throwStmt );
+                Statement * create_resume_rethrow( ThrowStmt * throwStmt );
+                CompoundStmt * take_try_block( TryStmt * tryStmt );
+                FunctionDecl * create_try_wrapper( CompoundStmt * body );
+                FunctionDecl * create_terminate_catch( CatchList &handlers );
+                CompoundStmt * create_single_matcher(
+                        DeclarationWithType * except_obj, CatchStmt * modded_handler );
+                FunctionDecl * create_terminate_match( CatchList &handlers );
+                CompoundStmt * create_terminate_caller( FunctionDecl * try_wrapper,
+                        FunctionDecl * terminate_catch, FunctionDecl * terminate_match );
+                FunctionDecl * create_resume_handler( CatchList &handlers );
+                CompoundStmt * create_resume_wrapper(
+                        Statement * wraps, FunctionDecl * resume_handler );
+                FunctionDecl * create_finally_wrapper( TryStmt * tryStmt );
+                ObjectDecl * create_finally_hook( FunctionDecl * finally_wrapper );
+                // Types used in translation, make sure to use clone.
+                // void (*function)();
+                FunctionType try_func_t;
+                // void (*function)(int, exception);
+                FunctionType catch_func_t;
+                // int (*function)(exception);
+                FunctionType match_func_t;
+                // bool (*function)(exception);
+                FunctionType handle_func_t;
+                // void (*function)(__attribute__((unused)) void *);
+                FunctionType finally_func_t;
+                StructInstType * create_except_type() {
+                        assert( except_decl );
+                        return new StructInstType( noQualifiers, except_decl );
+                }
+                void init_func_types();
+        public:
+                ExceptionMutatorCore() :
+                        cur_context( NoHandler ),
+                        handler_except_decl( nullptr ),
+                        except_decl( nullptr ), node_decl( nullptr ), hook_decl( nullptr ),
+                        try_func_t( noQualifiers, false ),
+                        catch_func_t( noQualifiers, false ),
+                        match_func_t( noQualifiers, false ),
+                        handle_func_t( noQualifiers, false ),
+                        finally_func_t( noQualifiers, false )
+                {}
+                void premutate( CatchStmt *catchStmt );
+                void premutate( StructDecl *structDecl );
+                Statement * postmutate( ThrowStmt *throwStmt );
+                Statement * postmutate( TryStmt *tryStmt );
+        };
+        void ExceptionMutatorCore::init_func_types() {
+                assert( except_decl );
+                ObjectDecl index_obj(
+                        "__handler_index",
+                        Type::StorageClasses(),
+                        LinkageSpec::Cforall,
+                        /*bitfieldWidth*/ NULL,
+                        new BasicType( noQualifiers, BasicType::SignedInt ),
+                        /*init*/ NULL
+                        );
+                ObjectDecl exception_obj(
+                        "__exception_inst",
+                        Type::StorageClasses(),
+                        LinkageSpec::Cforall,
+                        /*bitfieldWidth*/ NULL,
+                        new PointerType(
+                                noQualifiers,
+                                new StructInstType( noQualifiers, except_decl )
+                                ),
+                        /*init*/ NULL
+                        );
+                ObjectDecl bool_obj(
+                        "__ret_bool",
+                        Type::StorageClasses(),
+                        LinkageSpec::Cforall,
+                        /*bitfieldWidth*/ NULL,
+                        new BasicType( noQualifiers, BasicType::Bool ),
+                        /*init*/ NULL
+                        );
+                ObjectDecl voidptr_obj(
+                        "__hook",
+        // ThrowStmt Mutation Helpers
+        Statement * create_given_throw(
+                        const char * throwFunc, ThrowStmt * throwStmt ) {
+                // { int NAME = EXPR; throwFunc( &NAME ); }
+                CompoundStmt * result = new CompoundStmt( noLabels );
+                ObjectDecl * local = new ObjectDecl(
+                        "__local_exception_copy",
                         Type::StorageClasses(),
                         LinkageSpec::Cforall,
                         NULL,
+                        new PointerType(
+                                noQualifiers,
+                                new VoidType(
+                                        noQualifiers
+                                        ),
+                                std::list<Attribute *>{ new Attribute( "unused" ) }
+                                ),
+                        NULL
+                        );
+                catch_func_t.get_parameters().push_back( index_obj.clone() );
+                catch_func_t.get_parameters().push_back( exception_obj.clone() );
+                match_func_t.get_returnVals().push_back( index_obj.clone() );
+                match_func_t.get_parameters().push_back( exception_obj.clone() );
+                handle_func_t.get_returnVals().push_back( bool_obj.clone() );
+                handle_func_t.get_parameters().push_back( exception_obj.clone() );
+                finally_func_t.get_parameters().push_back( voidptr_obj.clone() );
+        }
+        // ThrowStmt Mutation Helpers
+        Statement * ExceptionMutatorCore::create_given_throw(
+                        const char * throwFunc, ThrowStmt * throwStmt ) {
+                // `throwFunc`( `throwStmt->get_name` );
+                        new BasicType( emptyQualifiers, BasicType::SignedInt ),
+                        new SingleInit( throwStmt->get_expr() )
+                        );
+                appendDeclStmt( result, local );
                 UntypedExpr * call = new UntypedExpr( new NameExpr( throwFunc ) );
+                call->get_args().push_back( throwStmt->get_expr() );
+                call->get_args().push_back( new AddressExpr( nameOf( local ) ) );
+                result->push_back( new ExprStmt( throwStmt->get_labels(), call ) );
                 throwStmt->set_expr( nullptr );
                 delete throwStmt;
+                return new ExprStmt( noLabels, call );
+        }
+        Statement * ExceptionMutatorCore::create_terminate_throw(
+                        ThrowStmt *throwStmt ) {
+                // __throw_terminate( `throwStmt->get_name()` ); }
+                return result;
+        }
+        Statement * create_terminate_throw( ThrowStmt *throwStmt ) {
+                // { int NAME = EXPR; __throw_terminate( &NAME ); }
                 return create_given_throw( "__cfaehm__throw_terminate", throwStmt );
+        }
+        Statement * ExceptionMutatorCore::create_terminate_rethrow(
+                        ThrowStmt *throwStmt ) {
+                // { `handler_except_decl` = NULL; __rethrow_terminate(); }
+        Statement * create_terminate_rethrow( ThrowStmt *throwStmt ) {
+                // __rethrow_terminate();
                 assert( nullptr == throwStmt->get_expr() );
+                assert( handler_except_decl );
+                CompoundStmt * result = new CompoundStmt( throwStmt->get_labels() );
+                result->push_back( new ExprStmt( noLabels, UntypedExpr::createAssign(
+                        nameOf( handler_except_decl ),
+                        new ConstantExpr( Constant::null(
+                                new PointerType(
+                                        noQualifiers,
+                                        handler_except_decl->get_type()->clone()
+                                        )
+                                ) )
+                        ) ) );
+                result->push_back( new ExprStmt(
+                        noLabels,
+                Statement * result = new ExprStmt(
+                        throwStmt->get_labels(),
                         new UntypedExpr( new NameExpr( "__cfaehm__rethrow_terminate" ) )
                         ) );
+                        );
                 delete throwStmt;
                 return result;
+        }
+        Statement * ExceptionMutatorCore::create_resume_throw(
+                        ThrowStmt *throwStmt ) {
+                // __throw_resume( `throwStmt->get_name` );
+        Statement * create_resume_throw( ThrowStmt *throwStmt ) {
+                // __throw_resume( EXPR );
                 return create_given_throw( "__cfaehm__throw_resume", throwStmt );
+        }
+        Statement * ExceptionMutatorCore::create_resume_rethrow(
+                        ThrowStmt *throwStmt ) {
+        Statement * create_resume_rethrow( ThrowStmt *throwStmt ) {
                 // return false;
                 Statement * result = new ReturnStmt(
 …
         // TryStmt Mutation Helpers
         CompoundStmt * ExceptionMutatorCore::take_try_block( TryStmt *tryStmt ) {
+        CompoundStmt * take_try_block( TryStmt *tryStmt ) {
                 CompoundStmt * block = tryStmt->get_block();
                 tryStmt->set_block( nullptr );
                 return block;
+        }
+        FunctionDecl * ExceptionMutatorCore::create_try_wrapper(
+                        CompoundStmt *body ) {
+        FunctionDecl * create_try_wrapper( CompoundStmt *body ) {
                 return new FunctionDecl( "try", Type::StorageClasses(),
 …
+        }
+        FunctionDecl * ExceptionMutatorCore::create_terminate_catch(
+                        CatchList &handlers ) {
+        FunctionDecl * create_terminate_catch( CatchList &handlers ) {
                 std::list<CaseStmt *> handler_wrappers;
                 FunctionType *func_type = catch_func_t.clone();
                 DeclarationWithType * index_obj = func_type->get_parameters().front();
                 DeclarationWithType * except_obj = func_type->get_parameters().back();
+        //      DeclarationWithType * except_obj = func_type->get_parameters().back();
                 // Index 1..{number of handlers}
 …
                         CatchStmt * handler = *it;
+                        // INTEGERconstant Version
                         // case `index`:
                         // {
+                        //     `handler.decl` = { (virtual `decl.type`)`except` };
+                        //     `handler.body`;
+                        //     `handler.body`
                         // }
                         // return;
+                        CompoundStmt * block = new CompoundStmt( noLabels );
+                        // Just copy the exception value. (Post Validation)
+                        ObjectDecl * handler_decl =
+                                static_cast<ObjectDecl *>( handler->get_decl() );
+                        ObjectDecl * local_except = handler_decl->clone();
+                        local_except->set_init(
+                                new ListInit({ new SingleInit(
+                                        new VirtualCastExpr( nameOf( except_obj ),
+                                                local_except->get_type()
+                                                )
+                                        ) })
+                                );
+                        block->push_back( new DeclStmt( noLabels, local_except ) );
+                        // Add the cleanup attribute.
+                        local_except->get_attributes().push_back( new Attribute(
+                                "cleanup",
+                                { new NameExpr( "__cfaehm__cleanup_terminate" ) }
+                                ) );
+                        // Update variables in the body to point to this local copy.
+                        {
+                                VarExprReplacer::DeclMap mapping;
+                                mapping[ handler_decl ] = local_except;
+                                VarExprReplacer mapper( mapping );
+                                handler->get_body()->accept( mapper );
+                        }
+                        block->push_back( handler->get_body() );
+                        std::list<Statement *> caseBody;
+                        caseBody.push_back( handler->get_body() );
                         handler->set_body( nullptr );
+                        std::list<Statement *> caseBody
+                                        { block, new ReturnStmt( noLabels, nullptr ) };
+                        caseBody.push_back( new ReturnStmt( noLabels, nullptr ) );
                         handler_wrappers.push_back( new CaseStmt(
                                 noLabels,
 …
         // Create a single check from a moddified handler.
         // except_obj is referenced, modded_handler will be freed.
         CompoundStmt * ExceptionMutatorCore::create_single_matcher(
+        CompoundStmt *create_single_matcher(
                         DeclarationWithType * except_obj, CatchStmt * modded_handler ) {
-                // {
-                //     `modded_handler.decl`
-                //     if ( `decl.name = (virtual `decl.type`)`except`
-                //             [&& `modded_handler.cond`] ) {
-                //         `modded_handler.body`
-                //     }
-                // }
                 CompoundStmt * block = new CompoundStmt( noLabels );
+                // Local Declaration
+                ObjectDecl * local_except =
+                        dynamic_cast<ObjectDecl *>( modded_handler->get_decl() );
+                assert( local_except );
+                block->push_back( new DeclStmt( noLabels, local_except ) );
+                // Check for type match.
+                Expression * cond = UntypedExpr::createAssign( nameOf( local_except ),
+                        new VirtualCastExpr( nameOf( except_obj ),
+                                local_except->get_type()->clone() ) );
+                // Add the check on the conditional if it is provided.
+                // INTEGERconstant Version
+                assert( nullptr == modded_handler->get_decl() );
+                ConstantExpr * number =
+                        dynamic_cast<ConstantExpr*>( modded_handler->get_cond() );
+                assert( number );
+                modded_handler->set_cond( nullptr );
+                Expression * cond;
+                {
+                        std::list<Expression *> args;
+                        args.push_back( number );
+                        std::list<Expression *> rhs_args;
+                        rhs_args.push_back( nameOf( except_obj ) );
+                        Expression * rhs = new UntypedExpr(
+                                new NameExpr( "*?" ), rhs_args );
+                        args.push_back( rhs );
+                        cond = new UntypedExpr( new NameExpr( "?==?" /*???*/), args );
+                }
                 if ( modded_handler->get_cond() ) {
                         cond = new LogicalExpr( cond, modded_handler->get_cond() );
+                }
-                // Construct the match condition.
                 block->push_back( new IfStmt( noLabels,
                         cond, modded_handler->get_body(), nullptr ) );
 …
+        }
+        FunctionDecl * ExceptionMutatorCore::create_terminate_match(
+                        CatchList &handlers ) {
+                // int match(exception * except) {
+                //     HANDLER WRAPPERS { return `index`; }
+                // }
+        FunctionDecl * create_terminate_match( CatchList &handlers ) {
                 CompoundStmt * body = new CompoundStmt( noLabels );
 …
+        }
         CompoundStmt * ExceptionMutatorCore::create_terminate_caller(
+        CompoundStmt * create_terminate_caller(
                         FunctionDecl * try_wrapper,
                         FunctionDecl * terminate_catch,
+                        FunctionDecl * terminate_match ) {
+                // { __cfaehm__try_terminate(`try`, `catch`, `match`); }
+                        FunctionDecl * terminate_match) {
                 UntypedExpr * caller = new UntypedExpr( new NameExpr(
 …
+        }
+        FunctionDecl * ExceptionMutatorCore::create_resume_handler(
+                        CatchList &handlers ) {
+                // bool handle(exception * except) {
+                //     HANDLER WRAPPERS { `hander->body`; return true; }
+                // }
+        FunctionDecl * create_resume_handler( CatchList &handlers ) {
                 CompoundStmt * body = new CompoundStmt( noLabels );
 …
+        }
+        CompoundStmt * ExceptionMutatorCore::create_resume_wrapper(
+        CompoundStmt * create_resume_wrapper(
+                        StructDecl * node_decl,
                         Statement * wraps,
                         FunctionDecl * resume_handler ) {
 …
+        }
+        FunctionDecl * ExceptionMutatorCore::create_finally_wrapper(
+                        TryStmt * tryStmt ) {
+                // void finally() { <finally code> }
+        FunctionDecl * create_finally_wrapper( TryStmt * tryStmt ) {
                 FinallyStmt * finally = tryStmt->get_finally();
                 CompoundStmt * body = finally->get_block();
 …
+        }
         ObjectDecl * ExceptionMutatorCore::create_finally_hook(
                         FunctionDecl * finally_wrapper ) {
+        ObjectDecl * create_finally_hook(
+                        StructDecl * hook_decl, FunctionDecl * finally_wrapper ) {
                 // struct __cfaehm__cleanup_hook __finally_hook
                 //      __attribute__((cleanup( finally_wrapper )));
 …
                         nullptr,
                         new StructInstType(
                                 noQualifiers,
+                                emptyQualifiers,
                                 hook_decl
                                 ),
 …
+        }
+        // Visiting/Mutating Functions
+        void ExceptionMutatorCore::premutate( CatchStmt *catchStmt ) {
+                // Validate the Statement's form.
+                ObjectDecl * decl =
+                        dynamic_cast<ObjectDecl *>( catchStmt->get_decl() );
+                if ( decl && true /* check decl->get_type() */ ) {
+                        // Pass.
+                } else if ( CatchStmt::Terminate == catchStmt->get_kind() ) {
+                        throw SemanticError("catch must have exception type");
+                } else {
+                        throw SemanticError("catchResume must have exception type");
+                }
+                // Track the handler context.
+                GuardValue( cur_context );
+                if ( CatchStmt::Terminate == catchStmt->get_kind() ) {
+                        cur_context = TerHandler;
+                        GuardValue( handler_except_decl );
+                        handler_except_decl = decl;
+                } else {
+                        cur_context = ResHandler;
+                }
+        }
+        void ExceptionMutatorCore::premutate( StructDecl *structDecl ) {
+                if ( !structDecl->has_body() ) {
+                        // Skip children?
+                        return;
+                } else if ( structDecl->get_name() == "__cfaehm__base_exception_t" ) {
+                        assert( nullptr == except_decl );
+                        except_decl = structDecl;
+                        init_func_types();
+                } else if ( structDecl->get_name() == "__cfaehm__try_resume_node" ) {
+                        assert( nullptr == node_decl );
+                        node_decl = structDecl;
+                } else if ( structDecl->get_name() == "__cfaehm__cleanup_hook" ) {
+                        assert( nullptr == hook_decl );
+                        hook_decl = structDecl;
+                }
+                // Later we might get the exception type as well.
+        }
+        class ExceptionMutatorCore : public WithGuards {
+                enum Context { NoHandler, TerHandler, ResHandler };
+                // Also need to handle goto, break & continue.
+                // They need to be cut off in a ResHandler, until we enter another
+                // loop, switch or the goto stays within the function.
+                Context cur_context;
+                // We might not need this, but a unique base for each try block's
+                // generated functions might be nice.
+                //std::string curFunctionName;
+                //unsigned int try_count = 0;
+                StructDecl *node_decl;
+                StructDecl *hook_decl;
+        public:
+                ExceptionMutatorCore() :
+                        cur_context(NoHandler),
+                        node_decl(nullptr), hook_decl(nullptr)
+                {}
+                void premutate( CatchStmt *catchStmt );
+                void premutate( StructDecl *structDecl );
+                Statement * postmutate( ThrowStmt *throwStmt );
+                Statement * postmutate( TryStmt *tryStmt );
+        };
         Statement * ExceptionMutatorCore::postmutate( ThrowStmt *throwStmt ) {
-                assert( except_decl );
                 // Ignoring throwStmt->get_target() for now.
                 if ( ThrowStmt::Terminate == throwStmt->get_kind() ) {
 …
         Statement * ExceptionMutatorCore::postmutate( TryStmt *tryStmt ) {
-                assert( except_decl );
                 assert( node_decl );
                 assert( hook_decl );
 …
                         appendDeclStmt( block, finally_block );
                         // Create and add the finally cleanup hook.
+                        appendDeclStmt( block, create_finally_hook( finally_block ) );
+                        appendDeclStmt( block,
+                                create_finally_hook( hook_decl, finally_block ) );
+                }
 …
                         appendDeclStmt( block, resume_handler );
                         // Prepare hooks
                         inner = create_resume_wrapper( inner, resume_handler );
+                        inner = create_resume_wrapper( node_decl, inner, resume_handler );
+                }
 …
                 block->push_back( inner );
+                //free_all( termination_handlers );
+                //free_all( resumption_handlers );
                 return block;
+        }
+        void ExceptionMutatorCore::premutate( CatchStmt *catchStmt ) {
+                GuardValue( cur_context );
+                if ( CatchStmt::Terminate == catchStmt->get_kind() ) {
+                        cur_context = TerHandler;
+                } else {
+                        cur_context = ResHandler;
+                }
+        }
+        void ExceptionMutatorCore::premutate( StructDecl *structDecl ) {
+                if ( !structDecl->has_body() ) {
+                        // Skip children?
+                        return;
+                } else if ( structDecl->get_name() == "__cfaehm__try_resume_node" ) {
+                        assert( nullptr == node_decl );
+                        node_decl = structDecl;
+                } else if ( structDecl->get_name() == "__cfaehm__cleanup_hook" ) {
+                        assert( nullptr == hook_decl );
+                        hook_decl = structDecl;
+                }
+                // Later we might get the exception type as well.
+        }
         void translateEHM( std::list< Declaration *> & translationUnit ) {
+                init_func_types();
                 PassVisitor<ExceptionMutatorCore> translator;
                 mutateAll( translationUnit, translator );

src/ControlStruct/ExceptTranslate.h

-              r0720e049
+              r3d4b23fa
 // Author           : Andrew Beach
 // Created On       : Tus Jun 06 10:13:00 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 09:19:23 2017
 // Update Count     : 4
+// Last Modified By : Andrew Beach
+// Last Modified On : Fri Jun 30 10:20:00 2017
+// Update Count     : 2
 //
+#pragma once
+#ifndef EXCEPT_TRANSLATE_H
+#define EXCEPT_TRANSLATE_H
 #include <list>
 …
 namespace ControlStruct {
         void translateEHM( std::list< Declaration *> & translationUnit );
+        // Converts exception handling structures into their underlying C code.  Translation does use the exception
+        // handling header, make sure it is visible wherever translation occurs.
+        /* Converts exception handling structures into their underlying C code.
+         * Translation does use the exception handling header, make sure it is
+         * visible wherever translation occurs.
+         */
+}
+// Local Variables: //
+// tab-width: 4 //
+// mode: c++ //
+// compile-command: "make install" //
+// End: //
+#endif // EXCEPT_TRANSLATE_H

src/ControlStruct/ForExprMutator.h

-              r0720e049
+              r3d4b23fa
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 09:17:08 2017
 // Update Count     : 4
+// Last Modified On : Mon Jan 25 21:22:13 2016
+// Update Count     : 3
 //
+#pragma once
+#ifndef FOR_MUTATOR_H
+#define FOR_MUTATOR_H
 #include "SynTree/Mutator.h"
 …
 } // namespace ControlStruct
+#endif // CHOOSE_MUTATOR_H
 // Local Variables: //
 // tab-width: 4 //

src/ControlStruct/LabelFixer.h

-              r0720e049
+              r3d4b23fa
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 09:17:24 2017
 // Update Count     : 34
+// Last Modified On : Tue Jul 12 17:36:16 2016
+// Update Count     : 33
 //
+#pragma once
+#ifndef LABEL_FIXER_H
+#define LABEL_FIXER_H
 #include "Common/utility.h"
 …
 } // namespace ControlStruct
+#endif // LABEL_FIXER_H
 // Local Variables: //
 // tab-width: 4 //

src/ControlStruct/LabelGenerator.h

-              r0720e049
+              r3d4b23fa
 // Author           : Rodolfo G. Esteves
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 09:20:14 2017
 // Update Count     : 6
+// Last Modified By : Rob Schluntz
+// Last Modified On : Wed Jun 03 14:16:26 2015
+// Update Count     : 5
 //
+#pragma once
+#ifndef LABEL_GENERATOR_H
+#define LABEL_GENERATOR_H
 #include "SynTree/SynTree.h"
 …
 } // namespace ControlStruct
+#endif // LABEL_GENERATOR_H
 // Local Variables: //
 // tab-width: 4 //

src/ControlStruct/MLEMutator.h

-              r0720e049
+              r3d4b23fa
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 09:19:59 2017
 // Update Count     : 35
+// Last Modified On : Tue Jul 12 17:37:01 2016
+// Update Count     : 34
 //
+#pragma once
+#ifndef MLE_MUTATOR_H
+#define MLE_MUTATOR_H
 #include <map>
 …
 } // namespace ControlStruct
+#endif // MLE_MUTATOR_H
 // Local Variables: //
 // tab-width: 4 //

src/ControlStruct/Mutate.h

-              r0720e049
+              r3d4b23fa
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 09:17:59 2017
 // Update Count     : 3
+// Last Modified On : Tue May 19 15:31:20 2015
+// Update Count     : 2
 //
+#pragma once
+#ifndef CTRLS_MUTATE_H
+#define CTRLS_MUTATE_H
 #include <list>
 …
 } // namespace ControlStruct
+#endif // CTRLS_MUTATE_H
 // Local Variables: //
 // tab-width: 4 //

src/GenPoly/Box.cc

-              r0720e049
+              r3d4b23fa
 #include "Box.h"
 #include "DeclMutator.h"
 #include "Lvalue.h"
+#include "PolyMutator.h"
 #include "FindFunction.h"
-#include "PolyMutator.h"
 #include "ScopedSet.h"
 #include "ScrubTyVars.h"
 …
                 };
                 /// Replaces initialization of polymorphic values with alloca, declaration of dtype/ftype with appropriate void expression, sizeof expressions of polymorphic types with the proper variable, and strips fields from generic struct declarations.
+                /// Replaces initialization of polymorphic values with alloca, declaration of dtype/ftype with appropriate void expression, and sizeof expressions of polymorphic types with the proper variable
                 class Pass3 final : public PolyMutator {
                   public:
 …
                         using PolyMutator::mutate;
                         virtual DeclarationWithType *mutate( FunctionDecl *functionDecl ) override;
-                        virtual Declaration *mutate( StructDecl *structDecl ) override;
-                        virtual Declaration *mutate( UnionDecl *unionDecl ) override;
                         virtual ObjectDecl *mutate( ObjectDecl *objectDecl ) override;
                         virtual TypedefDecl *mutate( TypedefDecl *objectDecl ) override;
 …
                 void Pass1::boxParam( Type *param, Expression *&arg, const TyVarMap &exprTyVars ) {
                         assertf( arg->has_result(), "arg does not have result: %s", toString( arg ).c_str() );
+                        assert( arg->has_result() );
                         if ( isPolyType( param, exprTyVars ) ) {
+                                Type * newType = arg->get_result()->clone();
+                                if ( env ) env->apply( newType );
+                                std::auto_ptr<Type> manager( newType );
+                                if ( isPolyType( newType ) ) {
+                                if ( isPolyType( arg->get_result() ) ) {
                                         // if the argument's type is polymorphic, we don't need to box again!
                                         return;
                                 } else if ( arg->get_result()->get_lvalue() ) {
+                                        // argument expression may be CFA lvalue, but not C lvalue -- apply generalizedLvalue transformations.
+                                        arg =  generalizedLvalue( new AddressExpr( arg ) );
+                                        // VariableExpr and MemberExpr are lvalues; need to check this isn't coming from the second arg of a comma expression though (not an lvalue)
+                                        // xxx - need to test that this code is still reachable
+                                        if ( CommaExpr *commaArg = dynamic_cast< CommaExpr* >( arg ) ) {
+                                                commaArg->set_arg2( new AddressExpr( commaArg->get_arg2() ) );
+                                        } else {
+                                                arg = new AddressExpr( arg );
+                                        }
                                         if ( ! ResolvExpr::typesCompatible( param, arg->get_result(), SymTab::Indexer() ) ) {
                                                 // silence warnings by casting boxed parameters when the actual type does not match up with the formal type.
 …
                 Expression *PolyGenericCalculator::mutate( SizeofExpr *sizeofExpr ) {
                         Type *ty = sizeofExpr->get_isType() ? sizeofExpr->get_type() : sizeofExpr->get_expr()->get_result();
+                        Type *ty = sizeofExpr->get_type();
                         if ( findGeneric( ty ) ) {
                                 Expression *ret = new NameExpr( sizeofName( mangleType( ty ) ) );
 …
                 Expression *PolyGenericCalculator::mutate( AlignofExpr *alignofExpr ) {
                         Type *ty = alignofExpr->get_isType() ? alignofExpr->get_type() : alignofExpr->get_expr()->get_result();
+                        Type *ty = alignofExpr->get_type();
                         if ( findGeneric( ty ) ) {
                                 Expression *ret = new NameExpr( alignofName( mangleType( ty ) ) );
 …
+                }
-                /// Strips the members from a generic aggregate
-                void stripGenericMembers(AggregateDecl* decl) {
-                        if ( ! decl->get_parameters().empty() ) decl->get_members().clear();
+                }
-                Declaration *Pass3::mutate( StructDecl *structDecl ) {
-                        stripGenericMembers( structDecl );
-                        return structDecl;
+                }
-                Declaration *Pass3::mutate( UnionDecl *unionDecl ) {
-                        stripGenericMembers( unionDecl );
-                        return unionDecl;
+                }
                 TypeDecl * Pass3::mutate( TypeDecl *typeDecl ) {
 //   Initializer *init = 0;

src/GenPoly/Box.h

-              r0720e049
+              r3d4b23fa
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 09:23:52 2017
 // Update Count     : 6
+// Last Modified On : Thu Nov 19 17:24:01 2015
+// Update Count     : 5
 //
+#pragma once
+#ifndef _BOX_H
+#define _BOX_H
 #include <list>
 …
 } // namespace GenPoly
+#endif // _BOX_H
 // Local Variables: //
 // tab-width: 4 //

src/GenPoly/CopyParams.h

-              r0720e049
+              r3d4b23fa
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 09:23:09 2017
 // Update Count     : 2
+// Last Modified On : Tue May 19 07:34:25 2015
+// Update Count     : 1
 //
+#pragma once
+#ifndef _COPYPARAMS_H
+#define _COPYPARAMS_H
 #include "SynTree/SynTree.h"
 …
 } // namespace GenPoly
+#endif // _COPYPARAMS_H
 // Local Variables: //
 // tab-width: 4 //

src/GenPoly/DeclMutator.h

-              r0720e049
+              r3d4b23fa
 // Created On       : Fri Nov 27 14:44:00 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 09:21:12 2017
 // Update Count     : 4
+// Last Modified On : Tue Jul 12 17:39:01 2016
+// Update Count     : 2
 //
+#pragma once
+#ifndef _DECLMUTATOR_H
+#define _DECLMUTATOR_H
 #include <list>
 …
         /// Mutates a list of declarations, providing a means of adding new declarations into the list
         class DeclMutator : public Mutator {
           public:
+        public:
                 typedef Mutator Parent;
 …
                 /// Called on exit from a scope; overriders should call this as a super-class call
                 virtual void doEndScope();
           protected:
+        protected:
                 /// Mutate a statement that forms its own scope
                 Statement* mutateStatement( Statement *stmt );
 …
                 /// Add a declaration to the list to be added after the current position
                 void addDeclarationAfter( Declaration* decl );
           private:
+        private:
                 /// A stack of declarations to add before the current declaration or statement
                 std::vector< std::list< Declaration* > > declsToAdd;
 …
 } // namespace
+#endif // _DECLMUTATOR_H
 // Local Variables: //
 // tab-width: 4 //

src/GenPoly/ErasableScopedMap.h

-              r0720e049
+              r3d4b23fa
 // Author           : Aaron B. Moss
 // Created On       : Wed Dec 2 11:37:00 2015
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Sat Jul 22 09:23:24 2017
+// Update Count     : 2
+//
+#pragma once
+// Last Modified By : Aaron B. Moss
+// Last Modified On : Wed Dec 2 11:37:00 2015
+// Update Count     : 1
+//
+#ifndef _ERASABLESCOPEDMAP_H
+#define _ERASABLESCOPEDMAP_H
 #include <cassert>
 …
 } // namespace GenPoly
+#endif // _ERASABLESCOPEDMAP_H
 // Local Variables: //
 // tab-width: 4 //

src/GenPoly/FindFunction.h

-              r0720e049
+              r3d4b23fa
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 09:23:36 2017
 // Update Count     : 2
+// Last Modified On : Tue May 19 07:36:35 2015
+// Update Count     : 1
 //
+#pragma once
+#ifndef FINDFUNCTION_H
+#define FINDFUNCTION_H
 #include "SynTree/SynTree.h"
 …
 } // namespace GenPoly
+#endif // FINDFUNCTION_H
 // Local Variables: //
 // tab-width: 4 //

src/GenPoly/GenPoly.h

-              r0720e049
+              r3d4b23fa
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 09:22:57 2017
 // Update Count     : 7
+// Last Modified By : Rob Schluntz
+// Last Modified On : Tue Nov 24 15:24:38 2015
+// Update Count     : 6
 //
+#pragma once
+#ifndef GENPOLY_H
+#define GENPOLY_H
 #include <string>
 …
 } // namespace GenPoly
+#endif // GENPOLY_H
 // Local Variables: //
 // tab-width: 4 //

src/GenPoly/InstantiateGeneric.h

-              r0720e049
+              r3d4b23fa
 // Author           : Aaron B. Moss
 // Created On       : Thu Aug 04 18:33:00 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 09:22:42 2017
 // Update Count     : 2
+// Last Modified By : Aaron B. Moss
+// Last Modified On : Thu Aug 04 18:33:00 2016
+// Update Count     : 1
 //
+#pragma once
+#ifndef _INSTANTIATEGENERIC_H
+#define _INSTANTIATEGENERIC_H
 #include "SynTree/SynTree.h"
 …
 } // namespace GenPoly
+#endif // _INSTANTIATEGENERIC_H
 // Local Variables: //
 // tab-width: 4 //

src/GenPoly/Lvalue.cc

-              r0720e049
+              r3d4b23fa
 #include "SynTree/Mutator.h"
 #include "SymTab/Indexer.h"
 #include "ResolvExpr/Resolver.h"
-#include "ResolvExpr/TypeEnvironment.h"
 #include "ResolvExpr/typeops.h"
-#include "ResolvExpr/Unify.h"
 #include "Common/UniqueName.h"
 …
                         typedef Mutator Parent;
-                        virtual Expression * mutate( MemberExpr * memExpr );
                         virtual Expression * mutate( AddressExpr * addressExpr );
-                        template<typename Func>
-                        Expression * applyTransformation( Expression * expr, Expression * arg, Func mkExpr );
                 };
         } // namespace
 …
                 acceptAll( translationUnit, p2 );
                 mutateAll( translationUnit, genLval );
+        }
-        Expression * generalizedLvalue( Expression * expr ) {
-                GeneralizedLvalue genLval;
-                return expr->acceptMutator( genLval );
+        }
 …
+                }
                 template<typename Func>
                 Expression * GeneralizedLvalue::applyTransformation( Expression * expr, Expression * arg, Func mkExpr ) {
                         if ( CommaExpr * commaExpr = dynamic_cast< CommaExpr * >( arg ) ) {
+                Expression * GeneralizedLvalue::mutate( AddressExpr * addrExpr ) {
+                        addrExpr = safe_dynamic_cast< AddressExpr * >( Parent::mutate( addrExpr ) );
+                        if ( CommaExpr * commaExpr = dynamic_cast< CommaExpr * >( addrExpr->get_arg() ) ) {
                                 Expression * arg1 = commaExpr->get_arg1()->clone();
                                 Expression * arg2 = commaExpr->get_arg2()->clone();
+                                Expression * ret = new CommaExpr( arg1, mkExpr( arg2 ) );
+                                ret->set_env( expr->get_env() );
+                                expr->set_env( nullptr );
+                                delete expr;
+                                return ret->acceptMutator( *this );
+                        } else if ( ConditionalExpr * condExpr = dynamic_cast< ConditionalExpr * >( arg ) ) {
+                                delete addrExpr;
+                                return new CommaExpr( arg1, new AddressExpr( arg2 ) );
+                        } else if ( ConditionalExpr * condExpr = dynamic_cast< ConditionalExpr * >( addrExpr->get_arg() ) ) {
                                 Expression * arg1 = condExpr->get_arg1()->clone();
                                 Expression * arg2 = condExpr->get_arg2()->clone();
                                 Expression * arg3 = condExpr->get_arg3()->clone();
+                                ConditionalExpr * ret = new ConditionalExpr( arg1, mkExpr( arg2 ), mkExpr( arg3 ) );
+                                ret->set_env( expr->get_env() );
+                                expr->set_env( nullptr );
+                                delete expr;
+                                // conditional expr type may not be either of the argument types, need to unify
+                                using namespace ResolvExpr;
+                                Type* commonType = nullptr;
+                                TypeEnvironment newEnv;
+                                AssertionSet needAssertions, haveAssertions;
+                                OpenVarSet openVars;
+                                unify( ret->get_arg2()->get_result(), ret->get_arg3()->get_result(), newEnv, needAssertions, haveAssertions, openVars, SymTab::Indexer(), commonType );
+                                ret->set_result( commonType ? commonType : ret->get_arg2()->get_result()->clone() );
+                                return ret->acceptMutator( *this );
+                                delete addrExpr;
+                                return new ConditionalExpr( arg1, new AddressExpr( arg2 ), new AddressExpr( arg3 ) );
+                        }
+                        return expr;
+                }
+                Expression * GeneralizedLvalue::mutate( MemberExpr * memExpr ) {
+                        Parent::mutate( memExpr );
+                        return applyTransformation( memExpr, memExpr->get_aggregate(), [=]( Expression * aggr ) { return new MemberExpr( memExpr->get_member(), aggr ); } );
+                }
+                Expression * GeneralizedLvalue::mutate( AddressExpr * addrExpr ) {
+                        addrExpr = safe_dynamic_cast< AddressExpr * >( Parent::mutate( addrExpr ) );
+                        return applyTransformation( addrExpr, addrExpr->get_arg(), []( Expression * arg ) { return new AddressExpr( arg ); } );
+                        return addrExpr;
+                }
         } // namespace

src/GenPoly/Lvalue.h

-              r0720e049
+              r3d4b23fa
 // file "LICENCE" distributed with Cforall.
 //
 // Lvalue.h --
+// Lvalue.h --
 //
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 09:21:59 2017
 // Update Count     : 2
+// Last Modified On : Tue May 19 07:42:09 2015
+// Update Count     : 1
 //
+#pragma once
+#ifndef _LVALUE_H
+#define _LVALUE_H
 #include <list>
 …
         /// replaces return type of `lvalue T` with `T*`, along with appropriate address-of and dereference operators
         void convertLvalue( std::list< Declaration* >& translationUnit );
+} // namespace GenPoly
+        /// applies transformations that allow GCC to accept more complicated lvalue expressions, e.g. &(a, b)
+        Expression * generalizedLvalue( Expression * expr );
+} // namespace GenPoly
+#endif // _LVALUE_H
 // Local Variables: //

src/GenPoly/PolyMutator.h

-              r0720e049
+              r3d4b23fa
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 09:20:31 2017
 // Update Count     : 7
+// Last Modified On : Tue Jul 12 17:39:41 2016
+// Update Count     : 6
 //
+#pragma once
+#ifndef _POLYMUTATOR_H
+#define _POLYMUTATOR_H
 #include <map>
 …
 } // namespace
+#endif // _POLYMUTATOR_H
 // Local Variables: //
 // tab-width: 4 //

src/GenPoly/ScopedSet.h

-              r0720e049
+              r3d4b23fa
 // Author           : Aaron B. Moss
 // Created On       : Thu Dec 3 11:51:00 2015
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Sat Jul 22 09:22:17 2017
+// Update Count     : 2
+//
+#pragma once
+// Last Modified By : Aaron B. Moss
+// Last Modified On : Thu Dec 3 11:51:00 2015
+// Update Count     : 1
+//
+#ifndef _SCOPEDSET_H
+#define _SCOPEDSET_H
 #include <iterator>
 …
 } // namespace GenPoly
+#endif // _SCOPEDSET_H
 // Local Variables: //
 // tab-width: 4 //

src/GenPoly/ScrubTyVars.h

-              r0720e049
+              r3d4b23fa
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 09:21:47 2017
 // Update Count     : 2
+// Last Modified On : Tue May 19 07:48:14 2015
+// Update Count     : 1
 //
+#pragma once
+#ifndef _SCRUBTYVARS_H
+#define _SCRUBTYVARS_H
 #include <string>
 …
 } // namespace GenPoly
+#endif // _SCRUBTYVARS_H
 // Local Variables: //
 // tab-width: 4 //

src/GenPoly/Specialize.h

-              r0720e049
+              r3d4b23fa
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 09:22:31 2017
 // Update Count     : 2
+// Last Modified On : Tue May 19 07:53:58 2015
+// Update Count     : 1
 //
+#pragma once
+#ifndef _SPECIALIZE_H
+#define _SPECIALIZE_H
 #include <list>
 …
 } // namespace GenPoly
+#endif // _SPECIALIZE_H
 // Local Variables: //
 // tab-width: 4 //

src/InitTweak/FixGlobalInit.h

-              r0720e049
+              r3d4b23fa
 // Author           : Rob Schluntz
 // Created On       : Mon May 04 15:14:56 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 09:30:54 2017
 // Update Count     : 3
+// Last Modified By : Rob Schluntz
+// Last Modified On : Fri May 06 16:07:47 2016
+// Update Count     : 2
 //
+#pragma once
+#ifndef FIX_GLOBAL_INIT_H
+#define FIX_GLOBAL_INIT_H
 #include <string>
 …
 } // namespace
+#endif // GENPOLY_POLYMUTATOR_H
 // Local Variables: //
 // tab-width: 4 //

src/InitTweak/FixInit.h

-              r0720e049
+              r3d4b23fa
 // Author           : Rob Schluntz
 // Created On       : Wed Jan 13 16:29:30 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 09:31:06 2017
 // Update Count     : 6
+// Last Modified By : Rob Schluntz
+// Last Modified On : Fri May 13 11:27:52 2016
+// Update Count     : 5
 //
+#pragma once
+#ifndef FIX_INIT_H
+#define FIX_INIT_H
 #include <string>
 …
 } // namespace
+#endif // GENPOLY_POLYMUTATOR_H
 // Local Variables: //
 // tab-width: 4 //

src/InitTweak/GenInit.h

-              r0720e049
+              r3d4b23fa
 // Author           : Rodolfo G. Esteves
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 09:31:19 2017
 // Update Count     : 4
+// Last Modified By : Rob Schluntz
+// Last Modified On : Fri May 13 11:27:19 2016
+// Update Count     : 3
 //
+#pragma once
+#ifndef GEN_INIT_H
+#define GEN_INIT_H
 #include <string>
 …
 } // namespace
+#endif // INITTWEAK_GENINIT_H
 // Local Variables: //
 // tab-width: 4 //

src/InitTweak/InitTweak.h

-              r0720e049
+              r3d4b23fa
 // Author           : Rob Schluntz
 // Created On       : Fri May 13 11:26:36 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 09:30:33 2017
 // Update Count     : 4
+// Last Modified By : Rob Schluntz
+// Last Modified On : Fri May 13 11:35:36 2016
+// Update Count     : 3
 //
+#pragma once
+#ifndef INIT_TWEAK_H
+#define INIT_TWEAK_H
 #include <string>
 …
 } // namespace
+#endif // INITTWEAK_GENINIT_H
 // Local Variables: //
 // tab-width: 4 //

src/MakeLibCfa.h

-              r0720e049
+              r3d4b23fa
 // Created On       : Sat May 16 10:42:14 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 09:31:35 2017
 // Update Count     : 2
+// Last Modified On : Sat May 16 10:43:29 2015
+// Update Count     : 1
 //
+#pragma once
+#ifndef LIBCFA_MAKELIBCFA_H
+#define LIBCFA_MAKELIBCFA_H
 #include <list>  // for list
 …
 } // namespace LibCfa
+#endif // LIBCFA_MAKELIBCFA_H
 // Local Variables: //
 // tab-width: 4 //

src/Makefile.am

-              r0720e049
+              r3d4b23fa
 ## Author           : Peter A. Buhr
 ## Created On       : Sun May 31 08:51:46 2015
 ## Last Modified By : Andrew Beach
 ## Last Modified On : Tus Jul 25 10:34:00 2017
 ## Update Count     : 76
+## Last Modified By : Peter A. Buhr
+## Last Modified On : Thu Oct 27 20:41:25 2016
+## Update Count     : 75
 ###############################################################################
 …
 include SynTree/module.mk
 include Tuples/module.mk
-include Virtual/module.mk
 # put into lib for now
 …
 cfa_cpplib_PROGRAMS = driver/cfa-cpp
 driver_cfa_cpp_SOURCES = ${SRC}
 driver_cfa_cpp_LDADD = -ldl                     # yywrap
+driver_cfa_cpp_LDADD = ${LEXLIB} -ldl                   # yywrap
 driver_cfa_cpp_CXXFLAGS = -Wno-deprecated -Wall -Wextra -DDEBUG_ALL -I${abs_top_srcdir}/src/include -DYY_NO_INPUT -O2 -g -std=c++14
 driver_cfa_cpp_LDFLAGS = -Xlinker -export-dynamic

src/Makefile.in

-              r0720e049
+              r3d4b23fa
 #SRC +=  ArgTweak/Rewriter.cc \
 #       ArgTweak/Mutate.cc
-######################### -*- Mode: Makefile-Gmake -*- ########################
-###############################################################################
 ######################### -*- Mode: Makefile-Gmake -*- ########################
 …
         Tuples/driver_cfa_cpp-TupleAssignment.$(OBJEXT) \
         Tuples/driver_cfa_cpp-TupleExpansion.$(OBJEXT) \
+        Tuples/driver_cfa_cpp-Explode.$(OBJEXT) \
+        Virtual/driver_cfa_cpp-ExpandCasts.$(OBJEXT)
+        Tuples/driver_cfa_cpp-Explode.$(OBJEXT)
 am_driver_cfa_cpp_OBJECTS = $(am__objects_1)
 driver_cfa_cpp_OBJECTS = $(am_driver_cfa_cpp_OBJECTS)
+driver_cfa_cpp_DEPENDENCIES =
+am__DEPENDENCIES_1 =
+driver_cfa_cpp_DEPENDENCIES = $(am__DEPENDENCIES_1)
 driver_cfa_cpp_LINK = $(CXXLD) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) \
         $(driver_cfa_cpp_LDFLAGS) $(LDFLAGS) -o $@
 …
         $(srcdir)/Parser/module.mk $(srcdir)/ResolvExpr/module.mk \
         $(srcdir)/SymTab/module.mk $(srcdir)/SynTree/module.mk \
         $(srcdir)/Tuples/module.mk $(srcdir)/Virtual/module.mk \
         $(top_srcdir)/automake/depcomp $(top_srcdir)/automake/ylwrap \
         Parser/lex.cc Parser/parser.cc Parser/parser.hh
+        $(srcdir)/Tuples/module.mk $(top_srcdir)/automake/depcomp \
+        $(top_srcdir)/automake/ylwrap Parser/lex.cc Parser/parser.cc \
+        Parser/parser.hh
 DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)
 ACLOCAL = @ACLOCAL@
 …
         SynTree/Attribute.cc SynTree/VarExprReplacer.cc \
         Tuples/TupleAssignment.cc Tuples/TupleExpansion.cc \
         Tuples/Explode.cc Virtual/ExpandCasts.cc
+        Tuples/Explode.cc
 MAINTAINERCLEANFILES = Parser/parser.output ${libdir}/${notdir \
         ${cfa_cpplib_PROGRAMS}}
 …
 cfa_cpplibdir = ${CFA_LIBDIR}
 driver_cfa_cpp_SOURCES = ${SRC}
 driver_cfa_cpp_LDADD = -ldl                     # yywrap
+driver_cfa_cpp_LDADD = ${LEXLIB} -ldl                   # yywrap
 driver_cfa_cpp_CXXFLAGS = -Wno-deprecated -Wall -Wextra -DDEBUG_ALL -I${abs_top_srcdir}/src/include -DYY_NO_INPUT -O2 -g -std=c++14
 driver_cfa_cpp_LDFLAGS = -Xlinker -export-dynamic
 …
 .SUFFIXES:
 .SUFFIXES: .cc .ll .o .obj .yy
 $(srcdir)/Makefile.in: @MAINTAINER_MODE_TRUE@ $(srcdir)/Makefile.am $(srcdir)/CodeGen/module.mk $(srcdir)/CodeTools/module.mk $(srcdir)/Concurrency/module.mk $(srcdir)/Common/module.mk $(srcdir)/ControlStruct/module.mk $(srcdir)/GenPoly/module.mk $(srcdir)/InitTweak/module.mk $(srcdir)/Parser/module.mk $(srcdir)/ResolvExpr/module.mk $(srcdir)/SymTab/module.mk $(srcdir)/SynTree/module.mk $(srcdir)/Tuples/module.mk $(srcdir)/Virtual/module.mk $(am__configure_deps)
+$(srcdir)/Makefile.in: @MAINTAINER_MODE_TRUE@ $(srcdir)/Makefile.am $(srcdir)/CodeGen/module.mk $(srcdir)/CodeTools/module.mk $(srcdir)/Concurrency/module.mk $(srcdir)/Common/module.mk $(srcdir)/ControlStruct/module.mk $(srcdir)/GenPoly/module.mk $(srcdir)/InitTweak/module.mk $(srcdir)/Parser/module.mk $(srcdir)/ResolvExpr/module.mk $(srcdir)/SymTab/module.mk $(srcdir)/SynTree/module.mk $(srcdir)/Tuples/module.mk $(am__configure_deps)
         @for dep in $?; do \
           case '$(am__configure_deps)' in \
 …
             cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe);; \
         esac;
 $(srcdir)/CodeGen/module.mk $(srcdir)/CodeTools/module.mk $(srcdir)/Concurrency/module.mk $(srcdir)/Common/module.mk $(srcdir)/ControlStruct/module.mk $(srcdir)/GenPoly/module.mk $(srcdir)/InitTweak/module.mk $(srcdir)/Parser/module.mk $(srcdir)/ResolvExpr/module.mk $(srcdir)/SymTab/module.mk $(srcdir)/SynTree/module.mk $(srcdir)/Tuples/module.mk $(srcdir)/Virtual/module.mk $(am__empty):
+$(srcdir)/CodeGen/module.mk $(srcdir)/CodeTools/module.mk $(srcdir)/Concurrency/module.mk $(srcdir)/Common/module.mk $(srcdir)/ControlStruct/module.mk $(srcdir)/GenPoly/module.mk $(srcdir)/InitTweak/module.mk $(srcdir)/Parser/module.mk $(srcdir)/ResolvExpr/module.mk $(srcdir)/SymTab/module.mk $(srcdir)/SynTree/module.mk $(srcdir)/Tuples/module.mk $(am__empty):
 $(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES)
 …
 Tuples/driver_cfa_cpp-Explode.$(OBJEXT): Tuples/$(am__dirstamp) \
         Tuples/$(DEPDIR)/$(am__dirstamp)
-Virtual/$(am__dirstamp):
-        @$(MKDIR_P) Virtual
-        @: > Virtual/$(am__dirstamp)
-Virtual/$(DEPDIR)/$(am__dirstamp):
-        @$(MKDIR_P) Virtual/$(DEPDIR)
-        @: > Virtual/$(DEPDIR)/$(am__dirstamp)
-Virtual/driver_cfa_cpp-ExpandCasts.$(OBJEXT): Virtual/$(am__dirstamp) \
-        Virtual/$(DEPDIR)/$(am__dirstamp)
 driver/$(am__dirstamp):
         @$(MKDIR_P) driver
 …
         -rm -f SynTree/*.$(OBJEXT)
         -rm -f Tuples/*.$(OBJEXT)
-        -rm -f Virtual/*.$(OBJEXT)
 distclean-compile:
 …
 @AMDEP_TRUE@@am__include@ @am__quote@Tuples/$(DEPDIR)/driver_cfa_cpp-TupleAssignment.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@Tuples/$(DEPDIR)/driver_cfa_cpp-TupleExpansion.Po@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@Virtual/$(DEPDIR)/driver_cfa_cpp-ExpandCasts.Po@am__quote@
 .cc.o:
 …
 @AMDEP_TRUE@@am__fastdepCXX_FALSE@      DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
 @am__fastdepCXX_FALSE@  $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o Tuples/driver_cfa_cpp-Explode.obj `if test -f 'Tuples/Explode.cc'; then $(CYGPATH_W) 'Tuples/Explode.cc'; else $(CYGPATH_W) '$(srcdir)/Tuples/Explode.cc'; fi`
-Virtual/driver_cfa_cpp-ExpandCasts.o: Virtual/ExpandCasts.cc
-@am__fastdepCXX_TRUE@   $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT Virtual/driver_cfa_cpp-ExpandCasts.o -MD -MP -MF Virtual/$(DEPDIR)/driver_cfa_cpp-ExpandCasts.Tpo -c -o Virtual/driver_cfa_cpp-ExpandCasts.o `test -f 'Virtual/ExpandCasts.cc' || echo '$(srcdir)/'`Virtual/ExpandCasts.cc
-@am__fastdepCXX_TRUE@   $(AM_V_at)$(am__mv) Virtual/$(DEPDIR)/driver_cfa_cpp-ExpandCasts.Tpo Virtual/$(DEPDIR)/driver_cfa_cpp-ExpandCasts.Po
-@AMDEP_TRUE@@am__fastdepCXX_FALSE@      $(AM_V_CXX)source='Virtual/ExpandCasts.cc' object='Virtual/driver_cfa_cpp-ExpandCasts.o' libtool=no @AMDEPBACKSLASH@
-@AMDEP_TRUE@@am__fastdepCXX_FALSE@      DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
-@am__fastdepCXX_FALSE@  $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o Virtual/driver_cfa_cpp-ExpandCasts.o `test -f 'Virtual/ExpandCasts.cc' || echo '$(srcdir)/'`Virtual/ExpandCasts.cc
-Virtual/driver_cfa_cpp-ExpandCasts.obj: Virtual/ExpandCasts.cc
-@am__fastdepCXX_TRUE@   $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT Virtual/driver_cfa_cpp-ExpandCasts.obj -MD -MP -MF Virtual/$(DEPDIR)/driver_cfa_cpp-ExpandCasts.Tpo -c -o Virtual/driver_cfa_cpp-ExpandCasts.obj `if test -f 'Virtual/ExpandCasts.cc'; then $(CYGPATH_W) 'Virtual/ExpandCasts.cc'; else $(CYGPATH_W) '$(srcdir)/Virtual/ExpandCasts.cc'; fi`
-@am__fastdepCXX_TRUE@   $(AM_V_at)$(am__mv) Virtual/$(DEPDIR)/driver_cfa_cpp-ExpandCasts.Tpo Virtual/$(DEPDIR)/driver_cfa_cpp-ExpandCasts.Po
-@AMDEP_TRUE@@am__fastdepCXX_FALSE@      $(AM_V_CXX)source='Virtual/ExpandCasts.cc' object='Virtual/driver_cfa_cpp-ExpandCasts.obj' libtool=no @AMDEPBACKSLASH@
-@AMDEP_TRUE@@am__fastdepCXX_FALSE@      DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
-@am__fastdepCXX_FALSE@  $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o Virtual/driver_cfa_cpp-ExpandCasts.obj `if test -f 'Virtual/ExpandCasts.cc'; then $(CYGPATH_W) 'Virtual/ExpandCasts.cc'; else $(CYGPATH_W) '$(srcdir)/Virtual/ExpandCasts.cc'; fi`
 .ll.cc:
 …
         -rm -f Tuples/$(DEPDIR)/$(am__dirstamp)
         -rm -f Tuples/$(am__dirstamp)
-        -rm -f Virtual/$(DEPDIR)/$(am__dirstamp)
-        -rm -f Virtual/$(am__dirstamp)
         -rm -f driver/$(am__dirstamp)
 …
 distclean: distclean-am
         -rm -rf ./$(DEPDIR) CodeGen/$(DEPDIR) CodeTools/$(DEPDIR) Common/$(DEPDIR) Concurrency/$(DEPDIR) ControlStruct/$(DEPDIR) GenPoly/$(DEPDIR) InitTweak/$(DEPDIR) Parser/$(DEPDIR) ResolvExpr/$(DEPDIR) SymTab/$(DEPDIR) SynTree/$(DEPDIR) Tuples/$(DEPDIR) Virtual/$(DEPDIR)
+        -rm -rf ./$(DEPDIR) CodeGen/$(DEPDIR) CodeTools/$(DEPDIR) Common/$(DEPDIR) Concurrency/$(DEPDIR) ControlStruct/$(DEPDIR) GenPoly/$(DEPDIR) InitTweak/$(DEPDIR) Parser/$(DEPDIR) ResolvExpr/$(DEPDIR) SymTab/$(DEPDIR) SynTree/$(DEPDIR) Tuples/$(DEPDIR)
         -rm -f Makefile
 distclean-am: clean-am distclean-compile distclean-generic \
 …
 maintainer-clean: maintainer-clean-am
         -rm -rf ./$(DEPDIR) CodeGen/$(DEPDIR) CodeTools/$(DEPDIR) Common/$(DEPDIR) Concurrency/$(DEPDIR) ControlStruct/$(DEPDIR) GenPoly/$(DEPDIR) InitTweak/$(DEPDIR) Parser/$(DEPDIR) ResolvExpr/$(DEPDIR) SymTab/$(DEPDIR) SynTree/$(DEPDIR) Tuples/$(DEPDIR) Virtual/$(DEPDIR)
+        -rm -rf ./$(DEPDIR) CodeGen/$(DEPDIR) CodeTools/$(DEPDIR) Common/$(DEPDIR) Concurrency/$(DEPDIR) ControlStruct/$(DEPDIR) GenPoly/$(DEPDIR) InitTweak/$(DEPDIR) Parser/$(DEPDIR) ResolvExpr/$(DEPDIR) SymTab/$(DEPDIR) SynTree/$(DEPDIR) Tuples/$(DEPDIR)
         -rm -f Makefile
 maintainer-clean-am: distclean-am maintainer-clean-generic

src/Parser/DeclarationNode.cc

-              r0720e049
+              r3d4b23fa
 // Created On       : Sat May 16 12:34:05 2015
 // Last Modified By : Andrew Beach
 // Last Modified On : Fri Jul 14 16:55:00 2017
 // Update Count     : 1020
+// Last Modified On : Wed Jun 28 15:27:00 2017
+// Update Count     : 1019
 //
 …
         newnode->type->aggregate.fields = fields;
         newnode->type->aggregate.body = body;
-        newnode->type->aggregate.tagged = false;
-        newnode->type->aggregate.parent = nullptr;
         return newnode;
 } // DeclarationNode::newAggregate
 …
         return newnode;
 } // DeclarationNode::newEnumConstant
-DeclarationNode * DeclarationNode::newTreeStruct( Aggregate kind, const string * name, const string * parent, ExpressionNode * actuals, DeclarationNode * fields, bool body ) {
-        assert( name );
-        DeclarationNode * newnode = new DeclarationNode;
-        newnode->type = new TypeData( TypeData::Aggregate );
-        newnode->type->aggregate.kind = kind;
-        newnode->type->aggregate.name = name;
-        newnode->type->aggregate.actuals = actuals;
-        newnode->type->aggregate.fields = fields;
-        newnode->type->aggregate.body = body;
-        newnode->type->aggregate.tagged = true;
-        newnode->type->aggregate.parent = parent;
-        return newnode;
-} // DeclarationNode::newTreeStruct
 DeclarationNode * DeclarationNode::newName( string * name ) {

src/Parser/ExpressionNode.cc

-              r0720e049
+              r3d4b23fa
 // Author           : Rodolfo G. Esteves
 // Created On       : Sat May 16 13:17:07 2015
+// Last Modified By : Andrew Beach
+// Last Modified On : Wed Aug  2 11:12:00 2017
+// Update Count     : 568
+//
+#include <climits>                                                                              // access INT_MAX, UINT_MAX, LONG_MAX, ULONG_MAX, LLONG_MAX
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Wed Jun 28 21:08:15 2017
+// Update Count     : 542
+//
+#include <cassert>
+#include <cctype>
+#include <climits>
+#include <cstdio>
+#include <algorithm>
 #include <sstream>
 …
 #include "SynTree/Expression.h"
 #include "SynTree/Declaration.h"
+#include "Common/UnimplementedError.h"
 #include "parserutility.h"
+#include "Common/utility.h"
 using namespace std;
 …
 // type.
 extern const Type::Qualifiers noQualifiers;             // no qualifiers on constants
+Type::Qualifiers emptyQualifiers;                               // no qualifiers on constants
 static inline bool checkU( char c ) { return c == 'u' || c == 'U'; }
 …
 static inline bool checkX( char c ) { return c == 'x' || c == 'X'; }
 Expression * build_constantInteger( const std::string & str ) {
+Expression *build_constantInteger( const std::string & str ) {
         static const BasicType::Kind kind[2][3] = {
                 { BasicType::SignedInt, BasicType::LongSignedInt, BasicType::LongLongSignedInt },
 …
         bool dec = true, Unsigned = false;                                      // decimal, unsigned constant
         int size;                                                                                       // 0 => int, 1 => long, 2 => long long
         unsigned long long int v;                                                       // converted integral value
+        unsigned long long int v;                                                               // converted integral value
         size_t last = str.length() - 1;                                         // last character of constant
+        Expression * ret;
+        // special constants
+        if ( str == "0" ) {
+                ret = new ConstantExpr( Constant( (Type *)new ZeroType( noQualifiers ), str, (unsigned long long int)0 ) );
+                goto CLEANUP;
+        } // if
+        if ( str == "1" ) {
+                ret = new ConstantExpr( Constant( (Type *)new OneType( noQualifiers ), str, (unsigned long long int)1 ) );
+                goto CLEANUP;
+        } // if
         if ( str[0] == '0' ) {                                                          // octal/hex constant ?
                 dec = false;
 …
         } // if
+        ret = new ConstantExpr( Constant( new BasicType( noQualifiers, kind[Unsigned][size] ), str, v ) );
+  CLEANUP:
+        Expression * ret = new ConstantExpr( Constant( new BasicType( emptyQualifiers, kind[Unsigned][size] ), str, v ) );
         delete &str;                                                                            // created by lex
         return ret;
 } // build_constantInteger
 Expression * build_constantFloat( const std::string & str ) {
+Expression *build_constantFloat( const std::string & str ) {
         static const BasicType::Kind kind[2][3] = {
                 { BasicType::Float, BasicType::Double, BasicType::LongDouble },
 …
         } // if
         Expression * ret = new ConstantExpr( Constant( new BasicType( noQualifiers, kind[complx][size] ), str, v ) );
+        Expression * ret = new ConstantExpr( Constant( new BasicType( emptyQualifiers, kind[complx][size] ), str, v ) );
         delete &str;                                                                            // created by lex
         return ret;
 } // build_constantFloat
 Expression * build_constantChar( const std::string & str ) {
         Expression * ret = new ConstantExpr( Constant( new BasicType( noQualifiers, BasicType::Char ), str, (unsigned long long int)(unsigned char)str[1] ) );
+Expression *build_constantChar( const std::string & str ) {
+        Expression * ret = new ConstantExpr( Constant( new BasicType( emptyQualifiers, BasicType::Char ), str, (unsigned long long int)(unsigned char)str[1] ) );
         delete &str;                                                                            // created by lex
         return ret;
 } // build_constantChar
 ConstantExpr * build_constantStr( const std::string & str ) {
+ConstantExpr *build_constantStr( const std::string & str ) {
         // string should probably be a primitive type
         ArrayType * at = new ArrayType( noQualifiers, new BasicType( Type::Qualifiers( Type::Const ), BasicType::Char ),
                                                                    new ConstantExpr( Constant::from_ulong( str.size() + 1 - 2 ) ), // +1 for '\0' and -2 for '"'
+        ArrayType *at = new ArrayType( emptyQualifiers, new BasicType( Type::Qualifiers( Type::Const ), BasicType::Char ),
+                                                                   new ConstantExpr( Constant::from_ulong( str.size() + 1 - 2 ) ),  // +1 for '\0' and -2 for '"'
                                                                    false, false );
+        ConstantExpr * ret = new ConstantExpr( Constant( at, str, (unsigned long long int)0 ) ); // constant 0 is ignored for pure string value
+        // constant 0 is ignored for pure string value
+        ConstantExpr * ret = new ConstantExpr( Constant( at, str, (unsigned long long int)0 ) );
         delete &str;                                                                            // created by lex
         return ret;
 } // build_constantStr
+Expression *build_constantZeroOne( const std::string & str ) {
+        Expression * ret = new ConstantExpr( Constant( str == "0" ? (Type *)new ZeroType( emptyQualifiers ) : (Type*)new OneType( emptyQualifiers ), str,
+                                                                                                   str == "0" ? (unsigned long long int)0 : (unsigned long long int)1 ) );
+        delete &str;                                                                            // created by lex
+        return ret;
+} // build_constantChar
 Expression * build_field_name_FLOATINGconstant( const std::string & str ) {
 …
 } // build_field_name_fraction_constants
 Expression * build_field_name_REALFRACTIONconstant( const std::string & str ) {
         if ( str.find_first_not_of( "0123456789", 1 ) != string::npos ) throw SemanticError( "invalid tuple index " + str );
 …
 } // build_field_name_REALDECIMALconstant
 NameExpr * build_varref( const string * name ) {
         NameExpr * expr = new NameExpr( *name, nullptr );
+NameExpr * build_varref( const string *name ) {
+        NameExpr *expr = new NameExpr( *name, nullptr );
         delete name;
         return expr;
+} // build_varref
+static const char * OperName[] = {                                              // must harmonize with OperKinds
+}
+static const char *OperName[] = {
         // diadic
         "SizeOf", "AlignOf", "OffsetOf", "?+?", "?-?", "?\\?", "?*?", "?/?", "?%?", "||", "&&",
+        "SizeOf", "AlignOf", "OffsetOf", "?+?", "?-?", "?*?", "?/?", "?%?", "||", "&&",
         "?|?", "?&?", "?^?", "Cast", "?<<?", "?>>?", "?<?", "?>?", "?<=?", "?>=?", "?==?", "?!=?",
         "?=?", "?@=?", "?\\=?", "?*=?", "?/=?", "?%=?", "?+=?", "?-=?", "?<<=?", "?>>=?", "?&=?", "?^=?", "?|=?",
+        "?=?", "?@=?", "?*=?", "?/=?", "?%=?", "?+=?", "?-=?", "?<<=?", "?>>=?", "?&=?", "?^=?", "?|=?",
         "?[?]", "...",
         // monadic
         "+?", "-?", "AddressOf", "*?", "!?", "~?", "++?", "?++", "--?", "?--", "&&"
 }; // OperName
 Expression * build_cast( DeclarationNode * decl_node, ExpressionNode * expr_node ) {
         Type * targetType = maybeMoveBuildType( decl_node );
+};
+Expression *build_cast( DeclarationNode *decl_node, ExpressionNode *expr_node ) {
+        Type *targetType = maybeMoveBuildType( decl_node );
         if ( dynamic_cast< VoidType * >( targetType ) ) {
                 delete targetType;
 …
                 return new CastExpr( maybeMoveBuild< Expression >(expr_node), targetType );
         } // if
+} // build_cast
+Expression * build_virtual_cast( DeclarationNode * decl_node, ExpressionNode * expr_node ) {
+        Type * targetType = maybeMoveBuildType( decl_node );
+        Expression * castArg = maybeMoveBuild< Expression >( expr_node );
+        return new VirtualCastExpr( castArg, targetType );
+} // build_virtual_cast
+Expression * build_fieldSel( ExpressionNode * expr_node, Expression * member ) {
+        UntypedMemberExpr * ret = new UntypedMemberExpr( member, maybeMoveBuild< Expression >(expr_node) );
+        return ret;
+} // build_fieldSel
+Expression * build_pfieldSel( ExpressionNode * expr_node, Expression * member ) {
+        UntypedExpr * deref = new UntypedExpr( new NameExpr( "*?" ) );
+}
+Expression *build_fieldSel( ExpressionNode *expr_node, Expression *member ) {
+        UntypedMemberExpr *ret = new UntypedMemberExpr( member, maybeMoveBuild< Expression >(expr_node) );
+        return ret;
+}
+Expression *build_pfieldSel( ExpressionNode *expr_node, Expression *member ) {
+        UntypedExpr *deref = new UntypedExpr( new NameExpr( "*?" ) );
         deref->location = expr_node->location;
         deref->get_args().push_back( maybeMoveBuild< Expression >(expr_node) );
         UntypedMemberExpr * ret = new UntypedMemberExpr( member, deref );
         return ret;
 } // build_pfieldSel
 Expression * build_addressOf( ExpressionNode * expr_node ) {
+        UntypedMemberExpr *ret = new UntypedMemberExpr( member, deref );
+        return ret;
+}
+Expression *build_addressOf( ExpressionNode *expr_node ) {
                 return new AddressExpr( maybeMoveBuild< Expression >(expr_node) );
+} // build_addressOf
+Expression * build_sizeOfexpr( ExpressionNode * expr_node ) {
+}
+Expression *build_sizeOfexpr( ExpressionNode *expr_node ) {
         return new SizeofExpr( maybeMoveBuild< Expression >(expr_node) );
+} // build_sizeOfexpr
+Expression * build_sizeOftype( DeclarationNode * decl_node ) {
+}
+Expression *build_sizeOftype( DeclarationNode *decl_node ) {
         return new SizeofExpr( maybeMoveBuildType( decl_node ) );
+} // build_sizeOftype
+Expression * build_alignOfexpr( ExpressionNode * expr_node ) {
+}
+Expression *build_alignOfexpr( ExpressionNode *expr_node ) {
         return new AlignofExpr( maybeMoveBuild< Expression >(expr_node) );
+} // build_alignOfexpr
+Expression * build_alignOftype( DeclarationNode * decl_node ) {
+}
+Expression *build_alignOftype( DeclarationNode *decl_node ) {
         return new AlignofExpr( maybeMoveBuildType( decl_node) );
+} // build_alignOftype
+Expression * build_offsetOf( DeclarationNode * decl_node, NameExpr * member ) {
+}
+Expression *build_offsetOf( DeclarationNode *decl_node, NameExpr *member ) {
         Expression * ret = new UntypedOffsetofExpr( maybeMoveBuildType( decl_node ), member->get_name() );
         delete member;
         return ret;
 } // build_offsetOf
 Expression * build_and_or( ExpressionNode * expr_node1, ExpressionNode * expr_node2, bool kind ) {
+}
+Expression *build_and_or( ExpressionNode *expr_node1, ExpressionNode *expr_node2, bool kind ) {
         return new LogicalExpr( notZeroExpr( maybeMoveBuild< Expression >(expr_node1) ), notZeroExpr( maybeMoveBuild< Expression >(expr_node2) ), kind );
 } // build_and_or
 Expression * build_unary_val( OperKinds op, ExpressionNode * expr_node ) {
+}
+Expression *build_unary_val( OperKinds op, ExpressionNode *expr_node ) {
         std::list< Expression * > args;
         args.push_back( maybeMoveBuild< Expression >(expr_node) );
         return new UntypedExpr( new NameExpr( OperName[ (int)op ] ), args );
+} // build_unary_val
+Expression * build_unary_ptr( OperKinds op, ExpressionNode * expr_node ) {
+}
+Expression *build_unary_ptr( OperKinds op, ExpressionNode *expr_node ) {
         std::list< Expression * > args;
         args.push_back( new AddressExpr( maybeMoveBuild< Expression >(expr_node) ) );
         return new UntypedExpr( new NameExpr( OperName[ (int)op ] ), args );
+} // build_unary_ptr
+Expression * build_binary_val( OperKinds op, ExpressionNode * expr_node1, ExpressionNode * expr_node2 ) {
+}
+Expression *build_binary_val( OperKinds op, ExpressionNode *expr_node1, ExpressionNode *expr_node2 ) {
         std::list< Expression * > args;
         args.push_back( maybeMoveBuild< Expression >(expr_node1) );
         args.push_back( maybeMoveBuild< Expression >(expr_node2) );
         return new UntypedExpr( new NameExpr( OperName[ (int)op ] ), args );
+} // build_binary_val
+Expression * build_binary_ptr( OperKinds op, ExpressionNode * expr_node1, ExpressionNode * expr_node2 ) {
+}
+Expression *build_binary_ptr( OperKinds op, ExpressionNode *expr_node1, ExpressionNode *expr_node2 ) {
         std::list< Expression * > args;
         args.push_back( new AddressExpr( maybeMoveBuild< Expression >(expr_node1) ) );
         args.push_back( maybeMoveBuild< Expression >(expr_node2) );
         return new UntypedExpr( new NameExpr( OperName[ (int)op ] ), args );
 } // build_binary_ptr
 Expression * build_cond( ExpressionNode * expr_node1, ExpressionNode * expr_node2, ExpressionNode * expr_node3 ) {
+}
+Expression *build_cond( ExpressionNode *expr_node1, ExpressionNode *expr_node2, ExpressionNode *expr_node3 ) {
         return new ConditionalExpr( notZeroExpr( maybeMoveBuild< Expression >(expr_node1) ), maybeMoveBuild< Expression >(expr_node2), maybeMoveBuild< Expression >(expr_node3) );
 } // build_cond
 Expression * build_comma( ExpressionNode * expr_node1, ExpressionNode * expr_node2 ) {
+}
+Expression *build_comma( ExpressionNode *expr_node1, ExpressionNode *expr_node2 ) {
         return new CommaExpr( maybeMoveBuild< Expression >(expr_node1), maybeMoveBuild< Expression >(expr_node2) );
 } // build_comma
 Expression * build_attrexpr( NameExpr * var, ExpressionNode * expr_node ) {
+}
+Expression *build_attrexpr( NameExpr *var, ExpressionNode * expr_node ) {
         return new AttrExpr( var, maybeMoveBuild< Expression >(expr_node) );
+} // build_attrexpr
+Expression * build_attrtype( NameExpr * var, DeclarationNode * decl_node ) {
+}
+Expression *build_attrtype( NameExpr *var, DeclarationNode * decl_node ) {
         return new AttrExpr( var, maybeMoveBuildType( decl_node ) );
 } // build_attrtype
 Expression * build_tuple( ExpressionNode * expr_node ) {
+}
+Expression *build_tuple( ExpressionNode * expr_node ) {
         std::list< Expression * > exprs;
         buildMoveList( expr_node, exprs );
         return new UntypedTupleExpr( exprs );;
 } // build_tuple
 Expression * build_func( ExpressionNode * function, ExpressionNode * expr_node ) {
+}
+Expression *build_func( ExpressionNode * function, ExpressionNode * expr_node ) {
         std::list< Expression * > args;
         buildMoveList( expr_node, args );
         return new UntypedExpr( maybeMoveBuild< Expression >(function), args, nullptr );
 } // build_func
 Expression * build_range( ExpressionNode * low, ExpressionNode * high ) {
+}
+Expression *build_range( ExpressionNode * low, ExpressionNode *high ) {
         return new RangeExpr( maybeMoveBuild< Expression >( low ), maybeMoveBuild< Expression >( high ) );
 } // build_range
 Expression * build_asmexpr( ExpressionNode * inout, ConstantExpr * constraint, ExpressionNode * operand ) {
+}
+Expression *build_asmexpr( ExpressionNode *inout, ConstantExpr *constraint, ExpressionNode *operand ) {
         return new AsmExpr( maybeMoveBuild< Expression >( inout ), constraint, maybeMoveBuild< Expression >(operand) );
 } // build_asmexpr
 Expression * build_valexpr( StatementNode * s ) {
+}
+Expression *build_valexpr( StatementNode *s ) {
         return new StmtExpr( dynamic_cast< CompoundStmt * >(maybeMoveBuild< Statement >(s) ) );
+} // build_valexpr
+Expression * build_typevalue( DeclarationNode * decl ) {
+}
+Expression *build_typevalue( DeclarationNode *decl ) {
         return new TypeExpr( maybeMoveBuildType( decl ) );
 } // build_typevalue
 Expression * build_compoundLiteral( DeclarationNode * decl_node, InitializerNode * kids ) {
+}
+Expression *build_compoundLiteral( DeclarationNode *decl_node, InitializerNode *kids ) {
         Declaration * newDecl = maybeBuild< Declaration >(decl_node); // compound literal type
         if ( DeclarationWithType * newDeclWithType = dynamic_cast< DeclarationWithType * >( newDecl ) ) { // non-sue compound-literal type
 …
                 assert( false );
         } // if
 } // build_compoundLiteral
+}
 // Local Variables: //

src/Parser/InitializerNode.cc

-              r0720e049
+              r3d4b23fa
 // Created On       : Sat May 16 13:20:24 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Jul 28 23:27:20 2017
 // Update Count     : 26
+// Last Modified On : Sat Oct  1 23:09:51 2016
+// Update Count     : 21
 //
 …
 #include "SynTree/Initializer.h"
 InitializerNode::InitializerNode( ExpressionNode * _expr, bool aggrp, ExpressionNode * des )
                 : expr( _expr ), aggregate( aggrp ), designator( des ), kids( nullptr ), maybeConstructed( true ) {
+InitializerNode::InitializerNode( ExpressionNode *_expr, bool aggrp, ExpressionNode *des )
+                : expr( _expr ), aggregate( aggrp ), designator( des ), kids( 0 ), maybeConstructed( true ) {
         if ( aggrp )
                 kids = dynamic_cast< InitializerNode * >( get_next() );
         if ( kids )
                 set_last( nullptr );
 } // InitializerNode::InitializerNode
+        if ( kids != 0 )
+                set_last( 0 );
+}
 InitializerNode::InitializerNode( InitializerNode * init, bool aggrp, ExpressionNode * des )
                 : expr( nullptr ), aggregate( aggrp ), designator( des ), kids( nullptr ), maybeConstructed( true ) {
         if ( init )
+InitializerNode::InitializerNode( InitializerNode *init, bool aggrp, ExpressionNode *des )
+                : expr( 0 ), aggregate( aggrp ), designator( des ), kids( 0 ), maybeConstructed( true ) {
+        if ( init != 0 )
                 set_last( init );
 …
                 kids = dynamic_cast< InitializerNode * >( get_next() );
         if ( kids )
                 set_next( nullptr );
 } // InitializerNode::InitializerNode
+        if ( kids != 0 )
+                set_next( 0 );
+}
 InitializerNode::~InitializerNode() {
 …
         delete designator;
         delete kids;
 } // InitializerNode::~InitializerNode
+}
 void InitializerNode::print( std::ostream &os, int indent ) const {
         os << std::string( indent, ' ' ) << "Initializer expression" << std::endl;
 } // InitializerNode::print
+}
 void InitializerNode::printOneLine( std::ostream &os ) const {
         if ( ! aggregate ) {
                 if ( designator ) {
+                if ( designator != 0 ) {
                         os << "designated by: (";
                         ExpressionNode *curdes = designator;
                         while ( curdes != nullptr) {
+                        while ( curdes != 0) {
                                 curdes->printOneLine(os);
                                 curdes = (ExpressionNode *)(curdes->get_next());
 …
                         os << ")";
                 } // if
                 if ( expr ) expr->printOneLine( os );
+                if ( expr ) expr->printOneLine(os);
         } else {  // It's an aggregate
                 os << "[--";
                 if ( next_init() != nullptr )
                         next_init()->printOneLine( os );
+                if ( next_init() != 0 )
+                        next_init()->printOneLine(os);
                 if (aggregate) os << "--]";
         } // if
 …
         if ( (moreInit = dynamic_cast< InitializerNode * >( get_next() ) ) ) {
                 moreInit->printOneLine( os );
         } // if
 } // InitializerNode::printOneLine
+        }
+}
 Initializer * InitializerNode::build() const {
+Initializer *InitializerNode::build() const {
         if ( aggregate ) {
                 // steal designators from children
 …
                 return new ListInit( initlist, designlist, maybeConstructed );
         } else {
                 if ( get_expression() ) {
+                if ( get_expression() != 0) {
                         return new SingleInit( maybeBuild< Expression >( get_expression() ), maybeConstructed );
                 } // if
+                }
         } // if
         return nullptr;
 } // InitializerNode::build
+        return 0;
+}
 // Local Variables: //

src/Parser/LinkageSpec.h

-              r0720e049
+              r3d4b23fa
 // Author           : Rodolfo G. Esteves
 // Created On       : Sat May 16 13:24:28 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 09:32:16 2017
 // Update Count     : 14
+// Last Modified By : Andrew Beach
+// Last Modified On : Fri Jul  7 11:03:00 2017
+// Update Count     : 13
 //
+#pragma once
+#ifndef LINKAGESPEC_H
+#define LINKAGESPEC_H
 #include <string>
 …
 };
+#endif // LINKAGESPEC_H
 // Local Variables: //
 // tab-width: 4 //

src/Parser/ParseNode.h

-              r0720e049
+              r3d4b23fa
 // Author           : Rodolfo G. Esteves
 // Created On       : Sat May 16 13:28:16 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Jul 27 12:08:08 2017
 // Update Count     : 788
+// Last Modified By : Andrew Beach
+// Last Modified On : Mon Jun 12 13:00:00 2017
+// Update Count     : 779
 //
+#pragma once
+#ifndef PARSENODE_H
+#define PARSENODE_H
 #include <string>
 …
 };
-// Must harmonize with OperName.
 enum class OperKinds {
         // diadic
         SizeOf, AlignOf, OffsetOf, Plus, Minus, Exp, Mul, Div, Mod, Or, And,
+        SizeOf, AlignOf, OffsetOf, Plus, Minus, Mul, Div, Mod, Or, And,
         BitOr, BitAnd, Xor, Cast, LShift, RShift, LThan, GThan, LEThan, GEThan, Eq, Neq,
         Assign, AtAssn, ExpAssn, MulAssn, DivAssn, ModAssn, PlusAssn, MinusAssn, LSAssn, RSAssn, AndAssn, ERAssn, OrAssn,
+        Assign, AtAssn, MulAssn, DivAssn, ModAssn, PlusAssn, MinusAssn, LSAssn, RSAssn, AndAssn, ERAssn, OrAssn,
         Index, Range,
         // monadic
 …
 Expression * build_constantFloat( const std::string &str );
 Expression * build_constantChar( const std::string &str );
+Expression * build_constantZeroOne( const std::string &str );
 ConstantExpr * build_constantStr( const std::string &str );
 Expression * build_field_name_FLOATINGconstant( const std::string & str );
 …
 Expression * build_cast( DeclarationNode * decl_node, ExpressionNode * expr_node );
-Expression * build_virtual_cast( DeclarationNode * decl_node, ExpressionNode * expr_node );
 Expression * build_fieldSel( ExpressionNode * expr_node, Expression * member );
 Expression * build_pfieldSel( ExpressionNode * expr_node, Expression * member );
 …
         static DeclarationNode * newAsmStmt( StatementNode * stmt ); // gcc external asm statement
-        // Perhaps this would best fold into newAggragate.
-        static DeclarationNode * newTreeStruct( Aggregate kind, const std::string * name, const std::string * parent, ExpressionNode * actuals, DeclarationNode * fields, bool body );
         DeclarationNode();
         ~DeclarationNode();
 …
         static UniqueName anonymous;
-        // Temp to test TreeStruct
-        const std::string * parent_name;
 }; // DeclarationNode
 …
 std::ostream & operator<<( std::ostream & out, const ParseNode * node );
+#endif // PARSENODE_H
 // Local Variables: //
 // tab-width: 4 //

src/Parser/ParserTypes.h

-              r0720e049
+              r3d4b23fa
 // Created On       : Sat Sep 22 08:58:10 2001
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 09:33:28 2017
 // Update Count     : 350
+// Last Modified On : Wed Jun 28 22:10:17 2017
+// Update Count     : 349
 //
+#pragma once
+#ifndef PARSER_HH
+#define PARSER_HH
 int yylex();
 …
 }; // Token
+#endif // PARSER_HH
 // Local Variables: //
 // tab-width: 4 //

src/Parser/TypeData.cc

-              r0720e049
+              r3d4b23fa
 // Created On       : Sat May 16 15:12:51 2015
 // Last Modified By : Andrew Beach
 // Last Modified On : Wed Aug  9 13:50:00 2017
 // Update Count     : 567
+// Last Modified On : Wed Jun 28 15:28:00 2017
+// Update Count     : 564
 //
 …
                 aggregate.fields = nullptr;
                 aggregate.body = false;
-                aggregate.tagged = false;
-                aggregate.parent = nullptr;
                 break;
           case AggregateInst:
 …
                 delete aggregate.actuals;
                 delete aggregate.fields;
-                delete aggregate.parent;
                 // delete aggregate;
                 break;
 …
                 newtype->aggregate.kind = aggregate.kind;
                 newtype->aggregate.body = aggregate.body;
-                newtype->aggregate.tagged = aggregate.tagged;
-                newtype->aggregate.parent = aggregate.parent ? new string( *aggregate.parent ) : nullptr;
                 break;
           case AggregateInst:
 …
           case TypeData::Builtin:
                 if(td->builtintype == DeclarationNode::Zero) {
                         return new ZeroType( noQualifiers );
+                        return new ZeroType( emptyQualifiers );
+                }
                 else if(td->builtintype == DeclarationNode::One) {
                         return new OneType( noQualifiers );
+                        return new OneType( emptyQualifiers );
+                }
                 else {
 …
         switch ( td->aggregate.kind ) {
           case DeclarationNode::Struct:
-                if ( td->aggregate.tagged ) {
-                        at = new StructDecl( *td->aggregate.name, td->aggregate.parent, attributes, linkage );
-                        buildForall( td->aggregate.params, at->get_parameters() );
-                        break;
+                }
           case DeclarationNode::Coroutine:
           case DeclarationNode::Monitor:
 …
 } // buildAggInst
 NamedTypeDecl * buildSymbolic( const TypeData * td, const string & name, Type::StorageClasses scs, LinkageSpec::Spec linkage ) {
+NamedTypeDecl * buildSymbolic( const TypeData * td, const string & name, Type::StorageClasses scs ) {
         assert( td->kind == TypeData::Symbolic );
         NamedTypeDecl * ret;
         assert( td->base );
         if ( td->symbolic.isTypedef ) {
                 ret = new TypedefDecl( name, scs, typebuild( td->base ), linkage );
+                ret = new TypedefDecl( name, scs, typebuild( td->base ) );
         } else {
                 ret = new TypeDecl( name, scs, typebuild( td->base ), TypeDecl::Any );
 …
                 return buildEnum( td, attributes );
         } else if ( td->kind == TypeData::Symbolic ) {
                 return buildSymbolic( td, name, scs, linkage );
+                return buildSymbolic( td, name, scs );
         } else {
                 return (new ObjectDecl( name, scs, linkage, bitfieldWidth, typebuild( td ), init, attributes ))->set_asmName( asmName );

src/Parser/TypeData.h

-              r0720e049
+              r3d4b23fa
 // Author           : Rodolfo G. Esteves
 // Created On       : Sat May 16 15:18:36 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 09:32:47 2017
 // Update Count     : 188
+// Last Modified By : Andrew Beach
+// Last Modified On : Wed Jun 28 15:29:00 2017
+// Update Count     : 186
 //
+#pragma once
+#ifndef TYPEDATA_H
+#define TYPEDATA_H
 #include "ParseNode.h"
 …
                 DeclarationNode * fields;
                 bool body;
-                bool tagged;
-                const std::string * parent;
         };
 …
 void buildKRFunction( const TypeData::Function_t & function );
+#endif // TYPEDATA_H
 // Local Variables: //
 // tab-width: 4 //

src/Parser/TypedefTable.h

-              r0720e049
+              r3d4b23fa
 // Created On       : Sat May 16 15:24:36 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 09:33:14 2017
 // Update Count     : 34
+// Last Modified On : Wed Jun 28 21:56:34 2017
+// Update Count     : 33
 //
+#pragma once
+#ifndef TYPEDEFTABLE_H
+#define TYPEDEFTABLE_H
 #include <map>
 …
 };
+#endif // TYPEDEFTABLE_H
 // Local Variables: //
 // tab-width: 4 //

src/Parser/lex.ll

-              r0720e049
+              r3d4b23fa
  * Created On       : Sat Sep 22 08:58:10 2001
  * Last Modified By : Peter A. Buhr
  * Last Modified On : Thu Jul 27 21:46:06 2017
  * Update Count     : 550
+ * Last Modified On : Wed Jul 12 18:04:44 2017
+ * Update Count     : 535
  */
 %option yylineno
-%option noyywrap
 %option nounput
 …
 op_unary {op_unary_only}|{op_unary_binary}|{op_unary_pre_post}
 op_binary_only "/"|"%"|"\\"|"^"|"&"|"|"|"<"|">"|"="|"=="|"!="|"<<"|">>"|"<="|">="|"+="|"-="|"*="|"/="|"%="|"\\="|"&="|"|="|"^="|"<<="|">>="
+op_binary_only "/"|"%"|"^"|"&"|"|"|"<"|">"|"="|"=="|"!="|"<<"|">>"|"<="|">="|"+="|"-="|"*="|"/="|"%="|"&="|"|="|"^="|"<<="|">>="
 op_binary_over {op_unary_binary}|{op_binary_only}
                                 // op_binary_not_over "?"|"->"|"."|"&&"|"||"|"@="
 …
 %%
                                 /* line directives */
+                                   /* line directives */
 ^{h_white}*"#"{h_white}*[0-9]+{h_white}*["][^"\n]+["].*"\n" {
         /* " stop highlighting */
 …
 int                             { KEYWORD_RETURN(INT); }
 __int128                { KEYWORD_RETURN(INT); }                                // GCC
-__int128_t              { KEYWORD_RETURN(INT); }                                // GCC
 __label__               { KEYWORD_RETURN(LABEL); }                              // GCC
 long                    { KEYWORD_RETURN(LONG); }
 …
 __typeof                { KEYWORD_RETURN(TYPEOF); }                             // GCC
 __typeof__              { KEYWORD_RETURN(TYPEOF); }                             // GCC
-__uint128_t             { KEYWORD_RETURN(INT); }                                // GCC
 union                   { KEYWORD_RETURN(UNION); }
 unsigned                { KEYWORD_RETURN(UNSIGNED); }
 __builtin_va_list { KEYWORD_RETURN(VALIST); }                   // GCC
-virtual                 { KEYWORD_RETURN(VIRTUAL); }                    // CFA
 void                    { KEYWORD_RETURN(VOID); }
 volatile                { KEYWORD_RETURN(VOLATILE); }
 …
                                 /* numeric constants */
+"0"                             { NUMERIC_RETURN(ZERO); }                               // CFA
+"1"                             { NUMERIC_RETURN(ONE); }                                // CFA
 {decimal_constant} { NUMERIC_RETURN(INTEGERconstant); }
 {octal_constant} { NUMERIC_RETURN(INTEGERconstant); }
 …
 "-"                             { ASCIIOP_RETURN(); }
 "*"                             { ASCIIOP_RETURN(); }
-"\\"                    { ASCIIOP_RETURN(); }                                   // CFA, exponentiation
 "/"                             { ASCIIOP_RETURN(); }
 "%"                             { ASCIIOP_RETURN(); }
 …
 "+="                    { NAMEDOP_RETURN(PLUSassign); }
 "-="                    { NAMEDOP_RETURN(MINUSassign); }
-"\\="                   { NAMEDOP_RETURN(EXPassign); }                  // CFA, exponentiation
 "*="                    { NAMEDOP_RETURN(MULTassign); }
 "/="                    { NAMEDOP_RETURN(DIVassign); }
 …
                                 /* unknown characters */
 .                               { printf("unknown character(s):\"%s\" on line %d\n", yytext, yylineno); }
+.                       { printf("unknown character(s):\"%s\" on line %d\n", yytext, yylineno); }
 %%

src/Parser/parser.yy

-              r0720e049
+              r3d4b23fa
 // Author           : Peter A. Buhr
 // Created On       : Sat Sep  1 20:22:55 2001
 // Last Modified By : Andrew Beach
 // Last Modified On : Wed Aug  4 13:33:00 2017
 // Update Count     : 2475
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Wed Jul 12 18:23:36 2017
+// Update Count     : 2426
 //
 …
 %token RESTRICT                                                                                 // C99
 %token ATOMIC                                                                                   // C11
+%token FORALL LVALUE MUTEX VIRTUAL                                              // CFA
+%token VOID CHAR SHORT INT LONG FLOAT DOUBLE SIGNED UNSIGNED
+%token FORALL LVALUE MUTEX                                                              // CFA
+%token VOID CHAR SHORT INT LONG FLOAT DOUBLE SIGNED UNSIGNED ZERO_T ONE_T
+%token VALIST                                                                                   // GCC
 %token BOOL COMPLEX IMAGINARY                                                   // C99
-%token ZERO_T ONE_T                                                                             // CFA
-%token VALIST                                                                                   // GCC
 %token TYPEOF LABEL                                                                             // GCC
 %token ENUM STRUCT UNION
 …
 // converted into the tuple index (.)(1). e.g., 3.x
 %token<tok>     REALDECIMALconstant     REALFRACTIONconstant    FLOATINGconstant
+%token<tok> ZERO                                ONE                                             // CFA
 // multi-character operators
 …
 %token ELLIPSIS                                                                                 // ...
 %token EXPassign        MULTassign      DIVassign       MODassign       // \=   *=      /=      %=
+%token MULTassign       DIVassign       MODassign                               // *=   /=      %=/
 %token PLUSassign       MINUSassign                                                     // +=   -=
 %token LSassign         RSassign                                                        // <<=  >>=
 …
 %token ATassign                                                                                 // @=
 %type<tok> identifier  no_attr_identifier
+%type<tok> identifier  no_attr_identifier  zero_one
 %type<tok> identifier_or_type_name  no_attr_identifier_or_type_name  attr_name
 %type<constant> string_literal
 …
 %type<op> ptrref_operator                               unary_operator                          assignment_operator
 %type<en> primary_expression                    postfix_expression                      unary_expression
+%type<en> cast_expression                               exponential_expression          multiplicative_expression       additive_expression
+%type<en> shift_expression                              relational_expression           equality_expression
+%type<en> AND_expression                                exclusive_OR_expression         inclusive_OR_expression
+%type<en> logical_AND_expression                logical_OR_expression
+%type<en> conditional_expression                constant_expression                     assignment_expression           assignment_expression_opt
+%type<en> cast_expression                               multiplicative_expression       additive_expression                     shift_expression
+%type<en> relational_expression                 equality_expression                     AND_expression                          exclusive_OR_expression
+%type<en> inclusive_OR_expression               logical_AND_expression          logical_OR_expression           conditional_expression
+%type<en> constant_expression                   assignment_expression           assignment_expression_opt
 %type<en> comma_expression                              comma_expression_opt
 %type<en> argument_expression_list              argument_expression                     default_initialize_opt
+%type<en> argument_expression_list              argument_expression                     assignment_opt
 %type<fctl> for_control_expression
 %type<en> subrange
 …
 %type<en> asm_clobbers_list_opt
 %type<flag> asm_volatile_opt
-%type<en> handler_predicate_opt
 // statements
 …
+        ;
+zero_one:                                                                                               // CFA
+        ZERO
+        | ONE
+        ;
 string_literal:
         string_literal_list                                                     { $$ = build_constantStr( *$1 ); }
 …
         IDENTIFIER                                                                                      // typedef name cannot be used as a variable name
                 { $$ = new ExpressionNode( build_varref( $1 ) ); }
+        | zero_one
+                { $$ = new ExpressionNode( build_constantZeroOne( *$1 ) ); }
         | tuple
         | '(' comma_expression ')'
 …
                         $$ = new ExpressionNode( build_field_name_fraction_constants( build_varref( $1 ), $2 ) );
+                }
+        | zero_one fraction_constants
+                {
+                        $$ = new ExpressionNode( build_field_name_fraction_constants( build_constantZeroOne( *$1 ), $2 ) );
+                }
+        ;
 …
         | ALIGNOF unary_expression                                                      // GCC, variable alignment
                 { $$ = new ExpressionNode( build_alignOfexpr( $2 ) ); }
         | ALIGNOF '(' type_no_function ')'                                      // GCC, type alignment
+        | ALIGNOF '(' type_no_function ')'                              // GCC, type alignment
                 { $$ = new ExpressionNode( build_alignOftype( $3 ) ); }
         | OFFSETOF '(' type_no_function ',' no_attr_identifier ')'
 …
         | '(' type_no_function ')' cast_expression
                 { $$ = new ExpressionNode( build_cast( $2, $4 ) ); }
-                // VIRTUAL cannot be opt because of look ahead issues
-        | '(' VIRTUAL ')' cast_expression
-                { $$ = new ExpressionNode( build_virtual_cast( nullptr, $4 ) ); }
-        | '(' VIRTUAL type_no_function ')' cast_expression
-                { $$ = new ExpressionNode( build_virtual_cast( $3, $5 ) ); }
 //      | '(' type_no_function ')' tuple
 //              { $$ = new ExpressionNode( build_cast( $2, $4 ) ); }
+        ;
 exponential_expression:
+multiplicative_expression:
         cast_expression
+        | exponential_expression '\\' cast_expression
+                { $$ = new ExpressionNode( build_binary_val( OperKinds::Exp, $1, $3 ) ); }
+        ;
+multiplicative_expression:
+        exponential_expression
+        | multiplicative_expression '*' exponential_expression
+        | multiplicative_expression '*' cast_expression
                 { $$ = new ExpressionNode( build_binary_val( OperKinds::Mul, $1, $3 ) ); }
         | multiplicative_expression '/' exponential_expression
+        | multiplicative_expression '/' cast_expression
                 { $$ = new ExpressionNode( build_binary_val( OperKinds::Div, $1, $3 ) ); }
         | multiplicative_expression '%' exponential_expression
+        | multiplicative_expression '%' cast_expression
                 { $$ = new ExpressionNode( build_binary_val( OperKinds::Mod, $1, $3 ) ); }
+        ;
 …
         '='                                                                                     { $$ = OperKinds::Assign; }
         | ATassign                                                                      { $$ = OperKinds::AtAssn; }
-        | EXPassign                                                                     { $$ = OperKinds::ExpAssn; }
         | MULTassign                                                            { $$ = OperKinds::MulAssn; }
         | DIVassign                                                                     { $$ = OperKinds::DivAssn; }
 …
 with_statement:
         WITH '(' tuple_expression_list ')' compound_statement
+        WITH identifier_list compound_statement
                 { $$ = (StatementNode *)0; }                                    // FIX ME
+        ;
 …
 handler_clause:
+        handler_key '(' push push exception_declaration pop handler_predicate_opt ')' compound_statement pop
+                { $$ = new StatementNode( build_catch( $1, $5, $7, $9 ) ); }
+        | handler_clause handler_key '(' push push exception_declaration pop handler_predicate_opt ')' compound_statement pop
+                { $$ = (StatementNode *)$1->set_last( new StatementNode( build_catch( $2, $6, $8, $10 ) ) ); }
+        ;
+handler_predicate_opt:
+        //empty
+                { $$ = nullptr; }
+        | ';' conditional_expression
+                { $$ = $2; }
+        // TEMPORARY, TEST EXCEPTIONS
+        handler_key '(' push push INTEGERconstant pop ')' compound_statement pop
+                { $$ = new StatementNode( build_catch( $1, nullptr, new ExpressionNode( build_constantInteger( *$5 ) ), $8 ) ); }
+        | handler_clause handler_key '(' push push INTEGERconstant pop ')' compound_statement pop
+                { $$ = (StatementNode *)$1->set_last( new StatementNode( build_catch( $2, nullptr, new ExpressionNode( build_constantInteger( *$6 ) ), $9 ) ) ); }
+        | handler_key '(' push push exception_declaration pop ')' compound_statement pop
+                { $$ = new StatementNode( build_catch( $1, $5, nullptr, $8 ) ); }
+        | handler_clause handler_key '(' push push exception_declaration pop ')' compound_statement pop
+                { $$ = (StatementNode *)$1->set_last( new StatementNode( build_catch( $2, $6, nullptr, $9 ) ) ); }
+        ;
 …
         | IMAGINARY                                                                                     // C99
                 { $$ = DeclarationNode::newComplexType( DeclarationNode::Imaginary ); }
+        | VALIST                                                                                        // GCC, __builtin_va_list
+                { $$ = DeclarationNode::newBuiltinType( DeclarationNode::Valist ); }
         | ZERO_T
                 { $$ = DeclarationNode::newBuiltinType( DeclarationNode::Zero ); }
         | ONE_T
                 { $$ = DeclarationNode::newBuiltinType( DeclarationNode::One ); }
-        | VALIST                                                                                        // GCC, __builtin_va_list
-                { $$ = DeclarationNode::newBuiltinType( DeclarationNode::Valist ); }
+        ;
 …
 cfa_parameter_declaration:                                                              // CFA, new & old style parameter declaration
         parameter_declaration
         | cfa_identifier_parameter_declarator_no_tuple identifier_or_type_name default_initialize_opt
+        | cfa_identifier_parameter_declarator_no_tuple identifier_or_type_name assignment_opt
                 { $$ = $1->addName( $2 ); }
         | cfa_abstract_tuple identifier_or_type_name default_initialize_opt
+        | cfa_abstract_tuple identifier_or_type_name assignment_opt
                 // To obtain LR(1), these rules must be duplicated here (see cfa_abstract_declarator).
                 { $$ = $1->addName( $2 ); }
         | type_qualifier_list cfa_abstract_tuple identifier_or_type_name default_initialize_opt
+        | type_qualifier_list cfa_abstract_tuple identifier_or_type_name assignment_opt
                 { $$ = $2->addName( $3 )->addQualifiers( $1 ); }
         | cfa_function_specifier
 …
 parameter_declaration:
                 // No SUE declaration in parameter list.
         declaration_specifier_nobody identifier_parameter_declarator default_initialize_opt
+        declaration_specifier_nobody identifier_parameter_declarator assignment_opt
+                {
                         typedefTable.addToEnclosingScope( TypedefTable::ID );
                         $$ = $2->addType( $1 )->addInitializer( $3 ? new InitializerNode( $3 ) : nullptr );
+                }
         | declaration_specifier_nobody type_parameter_redeclarator default_initialize_opt
+        | declaration_specifier_nobody type_parameter_redeclarator assignment_opt
+                {
                         typedefTable.addToEnclosingScope( TypedefTable::ID );
 …
 abstract_parameter_declaration:
         declaration_specifier_nobody default_initialize_opt
+        declaration_specifier_nobody assignment_opt
                 { $$ = $1->addInitializer( $2 ? new InitializerNode( $2 ) : nullptr ); }
         | declaration_specifier_nobody abstract_parameter_declarator default_initialize_opt
+        | declaration_specifier_nobody abstract_parameter_declarator assignment_opt
                 { $$ = $2->addType( $1 )->addInitializer( $3 ? new InitializerNode( $3 ) : nullptr ); }
+        ;
 …
         | '=' initializer
                 { $$ = $2; }
-        | '=' VOID
-                { $$ = nullptr; }
         | ATassign initializer
                 { $$ = $2->set_maybeConstructed( false ); }
 …
         // empty
                 { $$ = (StatementNode *)0; }                                    // FIX ME
         | WITH '(' tuple_expression_list ')'
+        | WITH identifier_list
                 { $$ = (StatementNode *)0; }                                    // FIX ME
+        ;
 …
+        ;
 default_initialize_opt:
+assignment_opt:
         // empty
                 { $$ = nullptr; }

src/Parser/parserutility.cc

-              r0720e049
+              r3d4b23fa
 // Author           : Rodolfo G. Esteves
 // Created On       : Sat May 16 15:30:39 2015
 // Last Modified By : Andrew Beach
 // Last Modified On : Tus Jul 18 10:12:00 2017
 // Update Count     : 8
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Wed Jun 28 22:11:32 2017
+// Update Count     : 7
 //
 …
         UntypedExpr *comparison = new UntypedExpr( new NameExpr( "?!=?" ) );
         comparison->get_args().push_back( orig );
         comparison->get_args().push_back( new ConstantExpr( Constant( new ZeroType( noQualifiers ), "0", (unsigned long long int)0 ) ) );
+        comparison->get_args().push_back( new ConstantExpr( Constant( new ZeroType( emptyQualifiers ), "0", (unsigned long long int)0 ) ) );
         return new CastExpr( comparison, new BasicType( Type::Qualifiers(), BasicType::SignedInt ) );
+}

src/Parser/parserutility.h

-              r0720e049
+              r3d4b23fa
 // Created On       : Sat May 16 15:31:46 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 09:32:58 2017
 // Update Count     : 4
+// Last Modified On : Wed Jun 28 22:11:40 2017
+// Update Count     : 3
 //
+#pragma once
+#ifndef PARSEUTILITY_H
+#define PARSEUTILITY_H
 #include "SynTree/SynTree.h"
 Expression *notZeroExpr( Expression *orig );
+#endif // PARSEUTILITY_H
 // Local Variables: //

src/ResolvExpr/Alternative.h

-              r0720e049
+              r3d4b23fa
 // Created On       : Sat May 16 23:45:43 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 09:36:36 2017
 // Update Count     : 3
+// Last Modified On : Sat May 16 23:54:39 2015
+// Update Count     : 2
 //
+#pragma once
+#ifndef ALTERNATIVE_H
+#define ALTERNATIVE_H
 #include <list>
 …
 } // namespace ResolvExpr
+#endif // ALTERNATIVE_H
 // Local Variables: //
 // tab-width: 4 //

src/ResolvExpr/AlternativeFinder.cc

-              r0720e049
+              r3d4b23fa
 // Author           : Richard C. Bilson
 // Created On       : Sat May 16 23:52:08 2015
 // Last Modified By : Andrew Beach
 // Last Modified On : Wed Jul 26 11:33:00 2017
 // Update Count     : 31
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Fri Mar 17 09:14:17 2017
+// Update Count     : 30
 //
 …
+        }
-        void AlternativeFinder::visit( VirtualCastExpr * castExpr ) {
-                assertf( castExpr->get_result(), "Implicate virtual cast targets not yet supported." );
-                AlternativeFinder finder( indexer, env );
-                // don't prune here, since it's guaranteed all alternatives will have the same type
-                // (giving the alternatives different types is half of the point of ConstructorExpr nodes)
-                finder.findWithAdjustment( castExpr->get_arg(), false );
-                for ( Alternative & alt : finder.alternatives ) {
-                        alternatives.push_back( Alternative(
-                                new VirtualCastExpr( alt.expr->clone(), castExpr->get_result()->clone() ),
-                                alt.env, alt.cost ) );
+                }
+        }
         void AlternativeFinder::visit( UntypedMemberExpr *memberExpr ) {
                 AlternativeFinder funcFinder( indexer, env );

src/ResolvExpr/AlternativeFinder.h

-              r0720e049
+              r3d4b23fa
 // Author           : Richard C. Bilson
 // Created On       : Sat May 16 23:56:12 2015
 // Last Modified By : Andrew Beach
 // Last Modified On : Wed Jul 26 11:24:00 2017
 // Update Count     : 4
+// Last Modified By : Rob Schluntz
+// Last Modified On : Tue Apr 19 11:44:53 2016
+// Update Count     : 2
 //
+#pragma once
+#ifndef ALTERNATIVEFINDER_H
+#define ALTERNATIVEFINDER_H
 #include <set>
 …
                 virtual void visit( AddressExpr *addressExpr );
                 virtual void visit( CastExpr *castExpr );
-                virtual void visit( VirtualCastExpr *castExpr );
                 virtual void visit( UntypedMemberExpr *memberExpr );
                 virtual void visit( MemberExpr *memberExpr );
 …
 } // namespace ResolvExpr
+#endif // ALTERNATIVEFINDER_H
 // Local Variables: //
 // tab-width: 4 //

src/ResolvExpr/AlternativePrinter.h

-              r0720e049
+              r3d4b23fa
 // Created On       : Sun May 17 06:55:43 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 09:37:09 2017
 // Update Count     : 4
+// Last Modified On : Sun May 17 06:57:12 2015
+// Update Count     : 3
 //
+#pragma once
+#ifndef ALTERNATIVEPRINTER_H
+#define ALTERNATIVEPRINTER_H
 #include <iostream>
 …
 } // namespace ResolvExpr
+#endif // ALTERNATIVEPRINTER_H
 // Local Variables: //
 // tab-width: 4 //

src/ResolvExpr/ConversionCost.h

-              r0720e049
+              r3d4b23fa
 // Created On       : Sun May 17 09:37:28 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 09:38:24 2017
 // Update Count     : 4
+// Last Modified On : Wed Mar  2 17:35:56 2016
+// Update Count     : 3
 //
+#pragma once
+#ifndef CONVERSIONCOST_H
+#define CONVERSIONCOST_H
 #include "SynTree/Visitor.h"
 …
 } // namespace ResolvExpr
+#endif // CONVERSIONCOST_H */
 // Local Variables: //
 // tab-width: 4 //

src/ResolvExpr/Cost.h

-              r0720e049
+              r3d4b23fa
 // Author           : Richard C. Bilson
 // Created On       : Sun May 17 09:39:50 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 09:35:55 2017
 // Update Count     : 5
+// Last Modified By : Rob Schluntz
+// Last Modified On : Wed Jul 22 16:43:10 2015
+// Update Count     : 4
 //
+#pragma once
+#ifndef COST_H
+#define COST_H
 #include <iostream>
 …
 } // namespace ResolvExpr
+#endif // COST_H
 // Local Variables: //
 // tab-width: 4 //

src/ResolvExpr/CurrentObject.cc

-              r0720e049
+              r3d4b23fa
                                 return constExpr->get_constant()->get_ival();
                         } else {
                                 assertf( false, "Non-integer constant expression in getConstValue %s", toString( constExpr ).c_str() ); // xxx - might be semantic error
+                                assertf( false, "Non-integer constant expression in getConstValue", toString( constExpr ).c_str() ); // xxx - might be semantic error
+                        }
                 } else if ( dynamic_cast< OneType * >( constExpr->get_result() ) ) {
 …
                                 setPosition( castExpr->get_arg() );
                         } else if ( VariableExpr * varExpr = dynamic_cast< VariableExpr * >( expr ) ) {
                                 assertf( dynamic_cast<EnumInstType *> ( varExpr->get_result() ), "ArrayIterator given variable that isn't an enum constant : %s", toString( expr ).c_str() );
+                                assertf( dynamic_cast<EnumInstType *> ( varExpr->get_result() ), "ArrayIterator given variable that isn't an enum constant", toString( expr ).c_str() );
                                 index = 0; // xxx - get actual value of enum constant
                         } else if ( dynamic_cast< SizeofExpr * >( expr ) || dynamic_cast< AlignofExpr * >( expr ) ) {
 …
                         curTypes = newTypes;
                         newTypes.clear();
                         assertf( desigAlts.size() == curTypes.size(), "Designator alternatives (%zu) and current types (%zu) out of sync", desigAlts.size(), curTypes.size() );
+                        assertf( desigAlts.size() == curTypes.size(), "Designator alternatives (%d) and current types (%d) out of sync", desigAlts.size(), curTypes.size() );
                 } // for
                 if ( desigAlts.size() > 1 ) {

src/ResolvExpr/CurrentObject.h

-              r0720e049
+              r3d4b23fa
 // Author           : Rob Schluntz
 // Created On       : Thu Jun  8 11:07:25 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 09:36:48 2017
 // Update Count     : 3
+// Last Modified By : Rob Schluntz
+// Last Modified On : Thu Jun  8 11:07:41 2017
+// Update Count     : 2
 //
+#pragma once
+#ifndef CURRENT_OBJECT_H
+#define CURRENT_OBJECT_H
 #include <stack>
 …
 } // namespace ResolvExpr
+#endif // CURRENT_OBJECT_H
 // Local Variables: //
 // tab-width: 4 //

src/ResolvExpr/FindOpenVars.h

-              r0720e049
+              r3d4b23fa
 // Created On       : Sun May 17 09:46:04 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 09:35:18 2017
 // Update Count     : 3
+// Last Modified On : Sun May 17 09:47:20 2015
+// Update Count     : 2
 //
+#pragma once
+#ifndef FINDOPENVARS_H
+#define FINDOPENVARS_H
 #include "Unify.h"
 …
 } // namespace ResolvExpr
+#endif // FINDOPENVARS_H
 // Local Variables: //
 // tab-width: 4 //

src/ResolvExpr/RenameVars.h

-              r0720e049
+              r3d4b23fa
 // Created On       : Sun May 17 12:10:28 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 09:33:54 2017
 // Update Count     : 4
+// Last Modified On : Wed Mar  2 17:36:39 2016
+// Update Count     : 3
 //
+#pragma once
+#ifndef RESOLVEXPR_RENAMEVARS_H
+#define RESOLVEXPR_RENAMEVARS_H
 #include <list>
 …
 } // namespace ResolvExpr
+#endif // RENAMEVARS_H
 // Local Variables: //
 // tab-width: 4 //

src/ResolvExpr/ResolveTypeof.h

-              r0720e049
+              r3d4b23fa
 // Created On       : Sun May 17 12:14:53 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 09:38:35 2017
 // Update Count     : 3
+// Last Modified On : Sun May 17 12:16:29 2015
+// Update Count     : 2
 //
+#pragma once
+#ifndef RESOLVETYPEOF_H
+#define RESOLVETYPEOF_H
 #include "SynTree/SynTree.h"
 …
 } // namespace ResolvExpr
+#endif // RESOLVETYPEOF_H
 // Local Variables: //
 // tab-width: 4 //

src/ResolvExpr/Resolver.cc

-              r0720e049
+              r3d4b23fa
 // Author           : Richard C. Bilson
 // Created On       : Sun May 17 12:17:01 2015
 // Last Modified By : Andrew Beach
 // Last Modified On : Tus Aug  8 16:06:00 2017
 // Update Count     : 212
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Thu Mar 23 17:23:14 2017
+// Update Count     : 211
 //
 …
                 virtual void visit( ReturnStmt *returnStmt ) override;
                 virtual void visit( ThrowStmt *throwStmt ) override;
-                virtual void visit( CatchStmt *catchStmt ) override;
                 virtual void visit( SingleInit *singleInit ) override;
 …
         void Resolver::visit( ThrowStmt *throwStmt ) {
-                // TODO: Replace *exception type with &exception type.
                 if ( throwStmt->get_expr() ) {
+                        StructDecl * exception_decl =
+                                lookupStruct( "__cfaehm__base_exception_t" );
+                        assert( exception_decl );
+                        Expression * wrapped = new CastExpr(
+                                throwStmt->get_expr(),
+                                new PointerType(
+                                        noQualifiers,
+                                        new StructInstType(
+                                                noQualifiers,
+                                                exception_decl
+                                                )
+                                        )
+                                );
+                        Expression * wrapped = new CastExpr( throwStmt->get_expr(), new BasicType( Type::Qualifiers(), BasicType::SignedInt ) );
                         Expression * newExpr = findSingleExpression( wrapped, *this );
                         throwStmt->set_expr( newExpr );
+                }
+        }
-        void Resolver::visit( CatchStmt *catchStmt ) {
-                if ( catchStmt->get_cond() ) {
-                        Expression * wrapped = new CastExpr(
-                                catchStmt->get_cond(),
-                                new BasicType( noQualifiers, BasicType::Bool )
-                                );
-                        catchStmt->set_cond( findSingleExpression( wrapped, *this ) );
+                }
+        }

src/ResolvExpr/Resolver.h

-              r0720e049
+              r3d4b23fa
 // Author           : Richard C. Bilson
 // Created On       : Sun May 17 12:18:34 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 09:36:57 2017
 // Update Count     : 3
+// Last Modified By : Rob Schluntz
+// Last Modified On : Thu Apr 14 15:06:53 2016
+// Update Count     : 2
 //
+#pragma once
+#ifndef RESOLVER_H
+#define RESOLVER_H
 #include "SynTree/SynTree.h"
 …
 } // namespace ResolvExpr
+#endif // RESOLVER_H
 // Local Variables: //
 // tab-width: 4 //

src/ResolvExpr/TypeEnvironment.h

-              r0720e049
+              r3d4b23fa
 // Created On       : Sun May 17 12:24:58 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 09:35:45 2017
 // Update Count     : 3
+// Last Modified On : Sun May 17 12:26:52 2015
+// Update Count     : 2
 //
+#pragma once
+#ifndef TYPEENVIRONMENT_H
+#define TYPEENVIRONMENT_H
 #include <string>
 …
 } // namespace ResolvExpr
+#endif // TYPEENVIRONMENT_H */
 // Local Variables: //
 // tab-width: 4 //

src/ResolvExpr/TypeMap.h

-              r0720e049
+              r3d4b23fa
 // Author           : Aaron B. Moss
 // Created On       : Fri Feb 19 13:55:00 2016
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Sat Jul 22 09:37:19 2017
+// Update Count     : 2
+//
+#pragma once
+// Last Modified By : Aaron B. Moss
+// Last Modified On : Fri Feb 19 13:55:00 2016
+// Update Count     : 1
+//
+#ifndef _TYPEMAP_H
+#define _TYPEMAP_H
 #include <map>
 …
 }  // namespace ResolvExpr
+#endif // _TYPEMAP_H
 // Local Variables: //
 // tab-width: 4 //

src/ResolvExpr/Unify.h

-              r0720e049
+              r3d4b23fa
 // Created On       : Sun May 17 13:09:04 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Jul 21 23:09:34 2017
 // Update Count     : 3
+// Last Modified On : Sun May 17 13:10:34 2015
+// Update Count     : 2
 //
+#pragma once
+#ifndef UNIFY_H
+#define UNIFY_H
 #include <map>
 …
 } // namespace ResolvExpr
+#endif // UNIFY_H
 // Local Variables: //
 // tab-width: 4 //

src/ResolvExpr/typeops.h

-              r0720e049
+              r3d4b23fa
 // Created On       : Sun May 17 07:28:22 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 09:36:18 2017
 // Update Count     : 3
+// Last Modified On : Sun May 17 07:33:11 2015
+// Update Count     : 2
 //
+#pragma once
+#ifndef TYPEOPS_H
+#define TYPEOPS_H
 #include "SynTree/SynTree.h"
 …
 } // namespace ResolvExpr
+#endif // TYPEOPS_H
 // Local Variables: //
 // tab-width: 4 //

src/SymTab/AddVisit.h

-              r0720e049
+              r3d4b23fa
 //
-#include "SynTree/Statement.h"
 namespace SymTab {
         void addDecls( std::list< Declaration* > &declsToAdd, std::list< Statement* > &statements, std::list< Statement* >::iterator i );
 …
                         if ( stmt == stmts.end() ) break;
                         // run mutator on statement
                         maybeAccept( *stmt, visitor );
 …
                         if ( decl == translationUnit.end() ) break;
                         // run mutator on declaration
                         maybeAccept( *decl, visitor );

src/SymTab/Autogen.cc

-              r0720e049
+              r3d4b23fa
 // Created On       : Thu Mar 03 15:45:56 2016
 // Last Modified By : Andrew Beach
 // Last Modified On : Fri Jul 14 16:41:00 2017
 // Update Count     : 62
+// Last Modified On : Wed Jun 28 15:30:00 2017
+// Update Count     : 61
 //
+#include <list>
+#include <iterator>
+#include "SynTree/Visitor.h"
+#include "SynTree/Type.h"
+#include "SynTree/Statement.h"
+#include "SynTree/TypeSubstitution.h"
+#include "Common/utility.h"
+#include "AddVisit.h"
+#include "MakeLibCfa.h"
 #include "Autogen.h"
+#include <algorithm>               // for count_if
+#include <cassert>                 // for safe_dynamic_cast, assert, assertf
+#include <iterator>                // for back_insert_iterator, back_inserter
+#include <list>                    // for list, _List_iterator, list<>::iter...
+#include <set>                     // for set, _Rb_tree_const_iterator
+#include <vector>                  // for vector
+#include "AddVisit.h"              // for addVisit
+#include "Common/ScopedMap.h"      // for ScopedMap<>::const_iterator, Scope...
+#include "Common/utility.h"        // for cloneAll, operator+
+#include "GenPoly/DeclMutator.h"   // for DeclMutator
+#include "GenPoly/ScopedSet.h"     // for ScopedSet, ScopedSet<>::iterator
+#include "SymTab/Mangler.h"        // for Mangler
+#include "SynTree/Mutator.h"       // for maybeMutate
+#include "SynTree/Statement.h"     // for CompoundStmt, ReturnStmt, ExprStmt
+#include "SynTree/Type.h"          // for FunctionType, Type, TypeInstType
+#include "SynTree/Visitor.h"       // for maybeAccept, Visitor, acceptAll
+class Attribute;
+#include "GenPoly/ScopedSet.h"
+#include "Common/ScopedMap.h"
+#include "SymTab/Mangler.h"
+#include "GenPoly/DeclMutator.h"
 namespace SymTab {
 …
         void makeStructFunctions( StructDecl *aggregateDecl, StructInstType *refType, unsigned int functionNesting, std::list< Declaration * > & declsToAdd, const std::vector< FuncData > & data ) {
                 // Builtins do not use autogeneration.
                 if ( aggregateDecl->get_linkage() == LinkageSpec::BuiltinCFA ||
+                if ( aggregateDecl->get_linkage() == LinkageSpec::Builtin ||
                          aggregateDecl->get_linkage() == LinkageSpec::BuiltinC ) {
                         return;
 …
                 // Make function polymorphic in same parameters as generic union, if applicable
                 const std::list< TypeDecl* > & typeParams = aggregateDecl->get_parameters(); // List of type variables to be placed on the generated functions
                 // default ctor/dtor need only first parameter
                 // void ?{}(T *); void ^?{}(T *);

src/SymTab/Autogen.h

-              r0720e049
+              r3d4b23fa
 // Created On       : Sun May 17 21:53:34 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 09:50:25 2017
 // Update Count     : 15
+// Last Modified On : Wed Jun 21 17:25:26 2017
+// Update Count     : 14
 //
+#pragma once
+#ifndef AUTOGEN_H
+#define AUTOGEN_H
+#include <cassert>                // for assert
+#include <iterator>               // for back_insert_iterator, back_inserter
+#include <list>                   // for list
+#include <string>                 // for string, operator==
+#include "Common/UniqueName.h"    // for UniqueName
+#include "InitTweak/InitTweak.h"  // for InitExpander
+#include "Parser/LinkageSpec.h"   // for C
+#include "SynTree/Constant.h"     // for Constant
+#include "SynTree/Declaration.h"  // for ObjectDecl, Declaration (ptr only)
+#include "SynTree/Expression.h"   // for UntypedExpr, NameExpr, VariableExpr
+#include "SynTree/Initializer.h"  // for SingleInit
+#include "SynTree/Label.h"        // for Label, noLabels
+#include "SynTree/Statement.h"    // for Statement (ptr only), CompoundStmt
+#include "SynTree/Type.h"         // for Type, ArrayType, Type::Qualifiers
+#include <string>
+#include "SynTree/Statement.h"
+#include "SynTree/Expression.h"
+#include "SynTree/Declaration.h"
+#include "SynTree/Initializer.h"
+#include "InitTweak/InitTweak.h"
 namespace SymTab {
 …
                 if ( isUnnamedBitfield( obj ) ) return;
                 bool addCast = (fname == "?{}" || fname == "^?{}") && ( !obj || ( obj && ! obj->get_bitfieldWidth() ) );
+                bool addCast = (fname == "?{}" || fname == "^?{}") && ( !obj || ( obj && obj->get_bitfieldWidth() == NULL ) );
                 std::list< Statement * > stmts;
                 genCall( srcParam, dstParam, fname, back_inserter( stmts ), obj->get_type(), addCast, forward );
 …
+        }
 } // namespace SymTab
+// Local Variables: //
+// tab-width: 4 //
+// mode: c++ //
+// compile-command: "make install" //
+// End: //
+#endif // AUTOGEN_H

src/SymTab/FixFunction.cc

-              r0720e049
+              r3d4b23fa
 #include "FixFunction.h"
+#include <list>                   // for list
+#include "Common/utility.h"       // for maybeClone
+#include "SynTree/Declaration.h"  // for FunctionDecl, ObjectDecl, Declarati...
+#include "SynTree/Type.h"         // for ArrayType, PointerType, Type, Basic...
+#include "SynTree/Declaration.h"
+#include "SynTree/Type.h"
+#include "SynTree/Expression.h"
+#include "Common/utility.h"
 namespace SymTab {

src/SymTab/FixFunction.h

-              r0720e049
+              r3d4b23fa
 // file "LICENCE" distributed with Cforall.
 //
 // FixFunction.h --
+// FixFunction.h --
 //
 // Author           : Richard C. Bilson
 // Created On       : Sun May 17 17:02:08 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 09:45:55 2017
 // Update Count     : 4
+// Last Modified On : Wed Mar  2 17:34:06 2016
+// Update Count     : 3
 //
+#pragma once
+#ifndef FIXFUNCTION_H
+#define FIXFUNCTION_H
+#include "SynTree/Mutator.h"  // for Mutator
+#include "SynTree/SynTree.h"  // for Types
+#include "SynTree/Mutator.h"
 namespace SymTab {
 …
                 virtual Type* mutate(ZeroType *zeroType);
                 virtual Type* mutate(OneType *oneType);
                 bool isVoid;
         };
 } // namespace SymTab
+#endif // FIXFUNCTION_H
 // Local Variables: //

src/SymTab/ImplementationType.cc

-              r0720e049
+              r3d4b23fa
 #include "ImplementationType.h"
+#include <list>                   // for list, _List_iterator, list<>::iterator
+#include "SymTab/Indexer.h"       // for Indexer
+#include "SynTree/Declaration.h"  // for NamedTypeDecl
+#include "SynTree/Type.h"         // for TupleType, Type, ArrayType, Pointer...
+#include "SynTree/Visitor.h"      // for Visitor
+#include "SynTree/Type.h"
+#include "SynTree/Declaration.h"
+#include "SynTree/Visitor.h"
+#include "SymTab/Indexer.h"
+#include "Common/utility.h"

src/SymTab/ImplementationType.h

-              r0720e049
+              r3d4b23fa
 // Created On       : Sun May 17 21:35:41 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 09:46:19 2017
 // Update Count     : 3
+// Last Modified On : Sun May 17 21:37:15 2015
+// Update Count     : 2
 //
+#pragma once
+#ifndef IMPLEMENTATIONTYPE_H
+#define IMPLEMENTATIONTYPE_H
+class Type;
+#include "SynTree/SynTree.h"
+#include "SymTab/Indexer.h"
 namespace SymTab {
-class Indexer;
         Type *implementationType( Type *, const SymTab::Indexer &indexer );
 …
 } // namespace SymTab
+#endif // IMPLEMENTATIONTYPE_H
 // Local Variables: //
 // tab-width: 4 //

src/SymTab/Indexer.cc

-              r0720e049
+              r3d4b23fa
 #include "Indexer.h"
+#include <cassert>                 // for assert, safe_dynamic_cast
+#include <iostream>                // for operator<<, basic_ostream, ostream
+#include <string>                  // for string, operator<<, operator!=
+#include <unordered_map>           // for operator!=, unordered_map<>::const...
+#include <unordered_set>           // for unordered_set
+#include <utility>                 // for pair, make_pair, move
+#include "Common/SemanticError.h"  // for SemanticError
+#include "Common/utility.h"        // for cloneAll
+#include "InitTweak/InitTweak.h"   // for isConstructor, isCopyFunction, isC...
+#include "Mangler.h"               // for Mangler
+#include "Parser/LinkageSpec.h"    // for isMangled, isOverridable, Spec
+#include "ResolvExpr/typeops.h"    // for typesCompatible
+#include "SynTree/Constant.h"      // for Constant
+#include "SynTree/Declaration.h"   // for DeclarationWithType, FunctionDecl
+#include "SynTree/Expression.h"    // for Expression, ImplicitCopyCtorExpr
+#include "SynTree/Initializer.h"   // for Initializer
+#include "SynTree/Statement.h"     // for CompoundStmt, Statement, ForStmt (...
+#include "SynTree/Type.h"          // for Type, StructInstType, UnionInstType
+#include <string>
+#include <typeinfo>
+#include <unordered_map>
+#include <unordered_set>
+#include <utility>
+#include <algorithm>
+#include "Mangler.h"
+#include "Common/utility.h"
+#include "ResolvExpr/typeops.h"
+#include "SynTree/Declaration.h"
+#include "SynTree/Type.h"
+#include "SynTree/Expression.h"
+#include "SynTree/Initializer.h"
+#include "SynTree/Statement.h"
+#include "InitTweak/InitTweak.h"
 #define debugPrint(x) if ( doDebug ) { std::cout << x; }

src/SymTab/Indexer.h

-              r0720e049
+              r3d4b23fa
 // Created On       : Sun May 17 21:38:55 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 09:46:34 2017
 // Update Count     : 7
+// Last Modified On : Wed Mar  2 17:34:14 2016
+// Update Count     : 6
 //
+#pragma once
+#ifndef INDEXER_H
+#define INDEXER_H
+#include <iosfwd>             // for ostream
+#include <list>               // for list
+#include <string>             // for string
+#include <list>
+#include <string>
+#include "SynTree/Visitor.h"  // for Visitor
+#include "SynTree/SynTree.h"  // for AST nodes
+#include "SynTree/Visitor.h"
 namespace SymTab {
 …
                 struct Impl;
                 Impl *tables;         ///< Copy-on-write instance of table data structure
                 unsigned long scope;  ///< Scope index of this pointer
 …
 } // namespace SymTab
+#endif // INDEXER_H
 // Local Variables: //
 // tab-width: 4 //

src/SymTab/Mangler.cc

-              r0720e049
+              r3d4b23fa
 // Update Count     : 21
 //
+#include <cassert>
+#include <string>
+#include <algorithm>
+#include <iterator>
+#include <functional>
+#include <set>
+#include "SynTree/Declaration.h"
+#include "SynTree/Type.h"
+#include "SynTree/Expression.h"
+#include "SynTree/Initializer.h"
+#include "SynTree/Statement.h"
 #include "Mangler.h"
+#include <algorithm>                // for copy, transform
+#include <cassert>                  // for assert, assertf
+#include <functional>               // for const_mem_fun_t, mem_fun
+#include <iterator>                 // for ostream_iterator, back_insert_ite...
+#include <list>                     // for _List_iterator, list, _List_const...
+#include <string>                   // for string, operator<<, basic_string
+#include "CodeGen/OperatorTable.h"  // for OperatorInfo, operatorLookup
+#include "Common/utility.h"         // for toString
+#include "Parser/LinkageSpec.h"     // for Spec, isOverridable, AutoGen, Int...
+#include "SynTree/Declaration.h"    // for TypeDecl, DeclarationWithType
+#include "SynTree/Expression.h"     // for TypeExpr, Expression, operator<<
+#include "SynTree/Type.h"           // for Type, ReferenceToType, Type::Fora...
+#include "CodeGen/OperatorTable.h"
 namespace SymTab {

src/SymTab/Mangler.h

-              r0720e049
+              r3d4b23fa
 // file "LICENCE" distributed with Cforall.
 //
 // Mangler.h --
+// Mangler.h --
 //
 // Author           : Richard C. Bilson
 // Created On       : Sun May 17 21:44:03 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 09:45:30 2017
 // Update Count     : 15
+// Last Modified By : Rob Schluntz
+// Last Modified On : Wed Aug 19 15:48:46 2015
+// Update Count     : 14
 //
+#pragma once
+#ifndef MANGLER_H
+#define MANGLER_H
+#include <map>                // for map, map<>::value_compare
+#include <sstream>            // for ostringstream
+#include <string>             // for string
+#include <utility>            // for pair
+#include "SynTree/SynTree.h"  // for Types
+#include "SynTree/Visitor.h"  // for Visitor, maybeAccept
+#include <sstream>
+#include "SynTree/SynTree.h"
+#include "SynTree/Visitor.h"
 namespace SymTab {
 …
                 virtual void visit( ZeroType *zeroType );
                 virtual void visit( OneType *oneType );
                 std::string get_mangleName() { return mangleName.str(); }
           private:
 …
                 bool mangleOverridable;         ///< Specially mangle overridable built-in methods
                 bool typeMode;                  ///< Produce a unique mangled name for a type
                 Mangler( bool mangleOverridable, bool typeMode );
                 Mangler( const Mangler & );
                 void mangleDecl( DeclarationWithType *declaration );
                 void mangleRef( ReferenceToType *refType, std::string prefix );
                 void mangleGenericRef( ReferenceToType *refType, std::string prefix );
                 void printQualifiers( Type *type );
         }; // Mangler
 …
 } // SymTab
+#endif // MANGLER_H
 // Local Variables: //
 // tab-width: 4 //

src/SymTab/TypeEquality.cc

-              r0720e049
+              r3d4b23fa
 // file "LICENCE" distributed with Cforall.
 //
 // TypeEquality.cc --
+// TypeEquality.cc --
 //
 // Author           : Rob Schluntz
 …
 // Update Count     : 37
 //
+#include <list>
+#include <iterator>
+#include "Validate.h"
+#include "SynTree/Visitor.h"
+#include "SynTree/Type.h"
+#include "SynTree/Statement.h"
+#include "SynTree/TypeSubstitution.h"
+#include "Indexer.h"
 #include "TypeEquality.h"
-#include <cassert>                // for assert
-#include <list>                   // for list, list<>::iterator, _List_iterator
-#include <string>                 // for operator==, string, basic_string
-#include "SynTree/Constant.h"     // for Constant
-#include "SynTree/Declaration.h"  // for DeclarationWithType
-#include "SynTree/Expression.h"   // for ConstantExpr, Expression
-#include "SynTree/Type.h"         // for Type, ArrayType, FunctionType, Enum...
-#include "SynTree/Visitor.h"      // for Visitor
 namespace SymTab {
         class TypeEquality : public Visitor {
   public:
                 TypeEquality( Type * other, bool vlaErr ) : result( true ), other( other ),
+                TypeEquality( Type * other, bool vlaErr ) : result( true ), other( other ),
                         vlaErr( vlaErr ) {}
                 bool result;
 …
                 handleQualifiers( basicType );
                 if ( BasicType * bt = dynamic_cast< BasicType * >( other ) ) {
                         result = result && basicType->get_kind() == bt->get_kind();
+                        result = result && basicType->get_kind() == bt->get_kind();
                 } else {
                         result = false;
 …
                         if ( vlaErr ) {
                                 // useful for comparing typedef types - in this case, we
+                                // useful for comparing typedef types - in this case, we
                                 // want types to appear distinct if either is a VLA type
                                 if ( arrayType->get_isVarLen() || at->get_isVarLen() ) {
 …
                         // parameter types must be equivalent
                         it1 = funcType->get_parameters().begin();
+                        it1 = funcType->get_parameters().begin();
                         it2 = ft->get_parameters().begin();
                         for ( ; it1 != funcType->get_parameters().end(); ++it1, ++it2 ) {

src/SymTab/TypeEquality.h

-              r0720e049
+              r3d4b23fa
 // file "LICENCE" distributed with Cforall.
 //
 // TypeEquality.h --
+// TypeEquality.h --
 //
 // Author           : Rob Schluntz
 …
 //
-class Type;
 namespace SymTab {
   // compare types t1 and t2 for equality
   // if vlaErr is true, then if at least one of the types is a
   // variable-length array type, then the result will be false
+  // if vlaErr is true, then if at least one of the types is a
+  // variable-length array type, then the result will be false
   bool typeEquals( Type * t1, Type * t2, bool vlaErr = false );
 } // namespace SymTab

src/SymTab/Validate.cc

-              r0720e049
+              r3d4b23fa
 // Author           : Richard C. Bilson
 // Created On       : Sun May 17 21:50:04 2015
 // Last Modified By : Andrew Beach
 // Last Modified On : Tus Aug  8 13:27:00 2017
 // Update Count     : 358
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Thu Mar 30 16:50:13 2017
+// Update Count     : 357
 //
 …
 //   definition occurs later in the input.
+#include <algorithm>
+#include <iterator>
+#include <list>
+#include "CodeGen/CodeGenerator.h"
+#include "Common/PassVisitor.h"
+#include "Common/ScopedMap.h"
+#include "Common/UniqueName.h"
+#include "Common/utility.h"
+#include "Concurrency/Keywords.h"
+#include "GenPoly/DeclMutator.h"
+#include "InitTweak/InitTweak.h"
+#include "AddVisit.h"
+#include "Autogen.h"
+#include "FixFunction.h"
+// #include "ImplementationType.h"
+#include "Indexer.h"
+#include "MakeLibCfa.h"
+#include "TypeEquality.h"
 #include "Validate.h"
+#include <cstddef>                     // for size_t
+#include <algorithm>                   // for move, transform
+#include <cassert>                     // for safe_dynamic_cast, assertf
+#include <iterator>                    // for back_inserter, inserter, back_...
+#include <list>                        // for list, _List_iterator, list<>::...
+#include <map>                         // for _Rb_tree_iterator, map, map<>:...
+#include <memory>                      // for unique_ptr, allocator
+#include <string>                      // for string, operator+, operator==
+#include <tuple>                       // for get
+#include <utility>                     // for pair, make_pair
+#include "AddVisit.h"                  // for addVisit
+#include "Autogen.h"                   // for SizeType, autogenerateRoutines
+#include "CodeGen/CodeGenerator.h"     // for genName
+#include "Common/PassVisitor.h"        // for PassVisitor, WithDeclsToAdd
+#include "Common/ScopedMap.h"          // for ScopedMap<>::const_iterator
+#include "Common/SemanticError.h"      // for SemanticError
+#include "Common/UniqueName.h"         // for UniqueName
+#include "Common/utility.h"            // for operator+, cloneAll, deleteAll
+#include "Concurrency/Keywords.h"      // for applyKeywords, implementMutexF...
+#include "FixFunction.h"               // for FixFunction
+#include "Indexer.h"                   // for Indexer
+#include "InitTweak/InitTweak.h"       // for isCtorDtor, isCtorDtorAssign
+#include "Parser/LinkageSpec.h"        // for C, Cforall
+#include "ResolvExpr/typeops.h"        // for extractResultType, typesCompat...
+#include "SynTree/Attribute.h"         // for Attribute
+#include "SynTree/Constant.h"          // for Constant
+#include "SynTree/Declaration.h"       // for EnumDecl, StructDecl, UnionDecl
+#include "SynTree/Expression.h"        // for TypeExpr, CompoundLiteralExpr
+#include "SynTree/Initializer.h"       // for ListInit, Initializer, noDesig...
+#include "SynTree/Mutator.h"           // for mutateAll, Mutator
+#include "SynTree/Statement.h"         // for CompoundStmt, DeclStmt, Return...
+#include "SynTree/Type.h"              // for Type, TypeInstType, TraitInstType
+#include "SynTree/TypeSubstitution.h"  // for TypeSubstitution, applySubstit...
+#include "SynTree/Visitor.h"           // for acceptAll, Visitor
+#include "ResolvExpr/typeops.h"
+#include "SynTree/Attribute.h"
+#include "SynTree/Expression.h"
+#include "SynTree/Mutator.h"
+#include "SynTree/Statement.h"
+#include "SynTree/Type.h"
+#include "SynTree/TypeSubstitution.h"
+#include "SynTree/Visitor.h"
 #define debugPrint( x ) if ( doDebug ) { std::cout << x; }
 …
                 // a return statement in a void-returning function in C. The expression is treated as if it
                 // were cast to void.
                 if ( ! returnStmt->get_expr() && returnVals.size() != 0 ) {
+                if ( returnStmt->get_expr() == NULL && returnVals.size() != 0 ) {
                         throw SemanticError( "Non-void function returns no values: " , returnStmt );
+                }
 …
                 Type *designatorType = tyDecl->get_base()->stripDeclarator();
                 if ( StructInstType *aggDecl = dynamic_cast< StructInstType * >( designatorType ) ) {
                         return new StructDecl( aggDecl->get_name(), DeclarationNode::Struct, noAttributes, tyDecl->get_linkage() );
+                        return new StructDecl( aggDecl->get_name() );
                 } else if ( UnionInstType *aggDecl = dynamic_cast< UnionInstType * >( designatorType ) ) {
                         return new UnionDecl( aggDecl->get_name(), noAttributes, tyDecl->get_linkage() );
+                        return new UnionDecl( aggDecl->get_name() );
                 } else if ( EnumInstType *enumDecl = dynamic_cast< EnumInstType * >( designatorType ) ) {
                         return new EnumDecl( enumDecl->get_name(), noAttributes, tyDecl->get_linkage() );
+                        return new EnumDecl( enumDecl->get_name() );
                 } else {
                         return ret->clone();
 …
                                 type = new EnumInstType( Type::Qualifiers(), newDeclEnumDecl->get_name() );
                         } // if
                         TypedefDeclPtr tyDecl( new TypedefDecl( aggDecl->get_name(), Type::StorageClasses(), type, aggDecl->get_linkage() ) );
+                        TypedefDeclPtr tyDecl( new TypedefDecl( aggDecl->get_name(), Type::StorageClasses(), type ) );
                         typedefNames[ aggDecl->get_name() ] = std::make_pair( std::move( tyDecl ), scopeLevel );
                 } // if
 …
         void validateGeneric( Aggr * inst ) {
                 std::list< TypeDecl * > * params = inst->get_baseParameters();
                 if ( params ) {
+                if ( params != NULL ) {
                         std::list< Expression * > & args = inst->get_parameters();
 …
                 FunctionType * ftype = functionDecl->get_functionType();
                 std::list< DeclarationWithType * > & retVals = ftype->get_returnVals();
                 assertf( retVals.size() == 0 || retVals.size() == 1, "Function %s has too many return values: %zu", functionDecl->get_name().c_str(), retVals.size() );
+                assertf( retVals.size() == 0 || retVals.size() == 1, "Function %s has too many return values: %d", functionDecl->get_name().c_str(), retVals.size() );
                 if ( retVals.size() == 1 ) {
                         // ensure all function return values have a name - use the name of the function to disambiguate (this also provides a nice bit of help for debugging).
 …
         void ArrayLength::previsit( ObjectDecl * objDecl ) {
                 if ( ArrayType * at = dynamic_cast< ArrayType * >( objDecl->get_type() ) ) {
                         if ( at->get_dimension() ) return;
+                        if ( at->get_dimension() != nullptr ) return;
                         if ( ListInit * init = dynamic_cast< ListInit * >( objDecl->get_init() ) ) {
                                 at->set_dimension( new ConstantExpr( Constant::from_ulong( init->get_initializers().size() ) ) );

src/SymTab/Validate.h

-              r0720e049
+              r3d4b23fa
 // Created On       : Sun May 17 21:53:34 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 09:46:07 2017
 // Update Count     : 4
+// Last Modified On : Tue May 19 16:49:43 2015
+// Update Count     : 3
 //
+#pragma once
+#ifndef VALIDATE_H
+#define VALIDATE_H
+#include <list>  // for list
+class Declaration;
+class Type;
+#include "SynTree/SynTree.h"
 namespace SymTab {
 …
 } // namespace SymTab
+#endif // VALIDATE_H
 // Local Variables: //
 // tab-width: 4 //

src/SymTab/module.mk

-              r0720e049
+              r3d4b23fa
 ## Author           : Richard C. Bilson
 ## Created On       : Mon Jun  1 17:49:17 2015
 ## Last Modified By : Andrew Beach
 ## Last Modified On : Thr Aug 10 16:08:00 2017
 ## Update Count     : 4
+## Last Modified By : Rob Schluntz
+## Last Modified On : Tue Jul 07 16:22:23 2015
+## Update Count     : 2
 ###############################################################################

src/SynTree/AddStmtVisitor.h

-              r0720e049
+              r3d4b23fa
 // Created On       : Wed Jun 22 12:05:48 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 09:51:08 2017
 // Update Count     : 9
+// Last Modified On : Tue Jul 12 17:50:32 2016
+// Update Count     : 8
 //
+#pragma once
+#ifndef ADD_STATEMENT_VISITOR_H
+#define ADD_STATEMENT_VISITOR_H
 #include <list>
 …
 };
+// Local Variables: //
+// tab-width: 4 //
+// mode: c++ //
+// compile-command: "make install" //
+// End: //
+#endif // ADD_STATEMENT_VISITOR_H

src/SynTree/AggregateDecl.cc

-              r0720e049
+              r3d4b23fa
 // Created On       : Sun May 17 23:56:39 2015
 // Last Modified By : Andrew Beach
 // Last Modified On : Fri Aug  4 14:22:00 2017
 // Update Count     : 22
+// Last Modified On : Tus Jun 27 15:30:00 2017
+// Update Count     : 21
 //
 …
         using std::endl;
+        os << typeString() << " " << get_name() << ":";
+        if ( get_linkage() != LinkageSpec::Cforall ) {
+                os << " " << LinkageSpec::linkageName( get_linkage() );
+        } // if
+        os << " with body " << has_body() << endl;
+        os << typeString() << " " << get_name();
+        os << string( indent+2, ' ' ) << "with body " << has_body() << endl;
         if ( ! parameters.empty() ) {

src/SynTree/ApplicationExpr.cc

r0720e049	r3d4b23fa
44	44	}
45	45
46		ApplicationExpr::ApplicationExpr( Expression funcExpr~~, const std::list< Expression > & argList ) : function( funcExpr ), args( argList~~ ) {
	46	ApplicationExpr::ApplicationExpr( Expression *funcExpr ) : function( funcExpr ) {
47	47	PointerType pointer = safe_dynamic_cast< PointerType >( funcExpr->get_result() );
48	48	FunctionType function = safe_dynamic_cast< FunctionType >( pointer->get_base() );

src/SynTree/Attribute.h

-              r0720e049
+              r3d4b23fa
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 09:54:14 2017
 // Update Count     : 39
+// Last Modified On : Wed Jan 18 16:27:11 2017
+// Update Count     : 38
 //
+#pragma once
+#ifndef GCC_ATTRIBUTE_H
+#define GCC_ATTRIBUTE_H
 #include "SynTree.h"
 …
 const std::list< Attribute * > noAttributes;
+#endif
 // Local Variables: //
 // tab-width: 4 //

src/SynTree/BaseSyntaxNode.h

-              r0720e049
+              r3d4b23fa
 //
+#pragma once
+#ifndef BASE_SYNTAX_NODE_H
+#define BASE_SYNTAX_NODE_H
 #include "Common/utility.h"
 …
 };
+#endif // BASE_SYNTAX_NODE_H
 // Local Variables: //
 // tab-width: 4 //

src/SynTree/Constant.cc

-              r0720e049
+              r3d4b23fa
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Andrew Beach
 // Last Modified On : Fri Jul 14 14:50:00 2017
 // Update Count     : 29
+// Last Modified On : Thr Jun 22 10:11:00 2017
+// Update Count     : 28
 //
 …
+}
-Constant Constant::null( Type * ptrtype ) {
-        if ( nullptr == ptrtype ) {
-                ptrtype = new PointerType(
-                        Type::Qualifiers(),
-                        new VoidType( Type::Qualifiers() )
-                        );
+        }
-        return Constant( ptrtype, "0", (unsigned long long int)0 );
+}
 unsigned long long Constant::get_ival() const {
         assertf( safe_dynamic_cast<BasicType*>(type)->isInteger(), "Attempt to retrieve ival from non-integer constant." );

src/SynTree/Constant.h

-              r0720e049
+              r3d4b23fa
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 09:54:46 2017
 // Update Count     : 17
+// Last Modified By : Andrew Beach
+// Last Modified On : Thr Jun 22 10:13:00 2017
+// Update Count     : 15
 //
+#pragma once
+#ifndef CONSTANT_H
+#define CONSTANT_H
 #include "SynTree.h"
 …
         static Constant from_double( double d );
-        /// generates a null pointer value for the given type. void * if omitted.
-        static Constant null( Type * ptrtype = nullptr );
         virtual void accept( Visitor & v ) { v.visit( this ); }
         virtual Constant * acceptMutator( Mutator & m ) { return m.mutate( this ); }
 …
 };
+#endif // CONSTANT_H
 // Local Variables: //
 // tab-width: 4 //

src/SynTree/Declaration.cc

-              r0720e049
+              r3d4b23fa
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Andrew Beach
 // Last Modified On : Wed Aug  9 14:38:00 2017
 // Update Count     : 25
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Thu Mar 16 07:49:18 2017
+// Update Count     : 24
 //
 …
 Declaration::Declaration( const std::string &name, Type::StorageClasses scs, LinkageSpec::Spec linkage )
                 : name( name ), linkage( linkage ), storageClasses( scs ), uniqueId( 0 ) {
+                : name( name ), storageClasses( scs ), linkage( linkage ), uniqueId( 0 ) {
+}
 Declaration::Declaration( const Declaration &other )
         : BaseSyntaxNode( other ), name( other.name ), linkage( other.linkage ), extension( other.extension ), storageClasses( other.storageClasses ), uniqueId( other.uniqueId ) {
+        : BaseSyntaxNode( other ), name( other.name ), storageClasses( other.storageClasses ), linkage( other.linkage ), uniqueId( other.uniqueId ) {
+}

src/SynTree/Declaration.h

-              r0720e049
+              r3d4b23fa
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Andrew Beach
+// Last Modified On : Wed Aug  9 14:45:00 2017
+// Update Count     : 126
+//
+#pragma once
+// Last Modified On : Tus Jun 27 15:31:00 2017
+// Update Count     : 122
+//
+#ifndef DECLARATION_H
+#define DECLARATION_H
 #include <string>
 …
 class Declaration : public BaseSyntaxNode {
   public:
-        std::string name;
-        LinkageSpec::Spec linkage;
-        bool extension = false;
         Declaration( const std::string &name, Type::StorageClasses scs, LinkageSpec::Spec linkage );
         Declaration( const Declaration &other );
 …
         static void dumpIds( std::ostream &os );
         static Declaration *declFromId( UniqueId id );
+  private:
+  private:
+        std::string name;
         Type::StorageClasses storageClasses;
+        LinkageSpec::Spec linkage;
         UniqueId uniqueId;
+        bool extension = false;
 };
 class DeclarationWithType : public Declaration {
   public:
+        DeclarationWithType( const std::string &name, Type::StorageClasses scs, LinkageSpec::Spec linkage, const std::list< Attribute * > & attributes, Type::FuncSpecifiers fs );
+        DeclarationWithType( const DeclarationWithType &other );
+        virtual ~DeclarationWithType();
+        std::string get_mangleName() const { return mangleName; }
+        DeclarationWithType * set_mangleName( std::string newValue ) { mangleName = newValue; return this; }
+        std::string get_scopedMangleName() const { return mangleName + "_" + std::to_string(scopeLevel); }
+        int get_scopeLevel() const { return scopeLevel; }
+        DeclarationWithType * set_scopeLevel( int newValue ) { scopeLevel = newValue; return this; }
+        ConstantExpr *get_asmName() const { return asmName; }
+        DeclarationWithType * set_asmName( ConstantExpr *newValue ) { asmName = newValue; return this; }
+        std::list< Attribute * >& get_attributes() { return attributes; }
+        const std::list< Attribute * >& get_attributes() const { return attributes; }
+        Type::FuncSpecifiers get_funcSpec() const { return fs; }
+        //void set_functionSpecifiers( Type::FuncSpecifiers newValue ) { fs = newValue; }
+        virtual DeclarationWithType *clone() const = 0;
+        virtual DeclarationWithType *acceptMutator( Mutator &m ) = 0;
+        virtual Type *get_type() const = 0;
+        virtual void set_type(Type *) = 0;
+  private:
         // this represents the type with all types and typedefs expanded it is generated by SymTab::Validate::Pass2
         std::string mangleName;
 …
         ConstantExpr *asmName;
         std::list< Attribute * > attributes;
-        DeclarationWithType( const std::string &name, Type::StorageClasses scs, LinkageSpec::Spec linkage, const std::list< Attribute * > & attributes, Type::FuncSpecifiers fs );
-        DeclarationWithType( const DeclarationWithType &other );
-        virtual ~DeclarationWithType();
-        std::string get_mangleName() const { return mangleName; }
-        DeclarationWithType * set_mangleName( std::string newValue ) { mangleName = newValue; return this; }
-        std::string get_scopedMangleName() const { return mangleName + "_" + std::to_string(scopeLevel); }
-        int get_scopeLevel() const { return scopeLevel; }
-        DeclarationWithType * set_scopeLevel( int newValue ) { scopeLevel = newValue; return this; }
-        ConstantExpr *get_asmName() const { return asmName; }
-        DeclarationWithType * set_asmName( ConstantExpr *newValue ) { asmName = newValue; return this; }
-        std::list< Attribute * >& get_attributes() { return attributes; }
-        const std::list< Attribute * >& get_attributes() const { return attributes; }
-        Type::FuncSpecifiers get_funcSpec() const { return fs; }
-        //void set_functionSpecifiers( Type::FuncSpecifiers newValue ) { fs = newValue; }
-        virtual DeclarationWithType *clone() const = 0;
-        virtual DeclarationWithType *acceptMutator( Mutator &m ) = 0;
-        virtual Type *get_type() const = 0;
-        virtual void set_type(Type *) = 0;
-  private:
         Type::FuncSpecifiers fs;
 };
 …
         typedef DeclarationWithType Parent;
   public:
-        Type *type;
-        Initializer *init;
-        Expression *bitfieldWidth;
         ObjectDecl( const std::string &name, Type::StorageClasses scs, LinkageSpec::Spec linkage, Expression *bitfieldWidth, Type *type, Initializer *init,
                                 const std::list< Attribute * > attributes = std::list< Attribute * >(), Type::FuncSpecifiers fs = Type::FuncSpecifiers() );
 …
         virtual void print( std::ostream &os, int indent = 0 ) const;
         virtual void printShort( std::ostream &os, int indent = 0 ) const;
+  private:
+        Type *type;
+        Initializer *init;
+        Expression *bitfieldWidth;
 };
 …
         typedef DeclarationWithType Parent;
   public:
-        FunctionType *type;
-        CompoundStmt *statements;
         FunctionDecl( const std::string &name, Type::StorageClasses scs, LinkageSpec::Spec linkage, FunctionType *type, CompoundStmt *statements,
                                   const std::list< Attribute * > attributes = std::list< Attribute * >(), Type::FuncSpecifiers fs = Type::FuncSpecifiers() );
 …
         virtual void print( std::ostream &os, int indent = 0 ) const;
         virtual void printShort( std::ostream &os, int indent = 0 ) const;
+  private:
+        FunctionType *type;
+        CompoundStmt *statements;
 };
 …
         typedef Declaration Parent;
   public:
-        Type *base;
-        std::list< TypeDecl* > parameters;
-        std::list< DeclarationWithType* > assertions;
         NamedTypeDecl( const std::string &name, Type::StorageClasses scs, Type *type );
         NamedTypeDecl( const NamedTypeDecl &other );
 …
         virtual void print( std::ostream &os, int indent = 0 ) const;
         virtual void printShort( std::ostream &os, int indent = 0 ) const;
+  protected:
+  private:
+        Type *base;
+        std::list< TypeDecl* > parameters;
+        std::list< DeclarationWithType* > assertions;
 };
 …
   public:
         enum Kind { Any, Dtype, Ftype, Ttype };
-        Type * init;
-        bool sized;
         /// Data extracted from a type decl
         struct Data {
 …
   private:
         Kind kind;
+        Type * init;
+        bool sized;
 };
 …
         typedef NamedTypeDecl Parent;
   public:
         TypedefDecl( const std::string &name, Type::StorageClasses scs, Type *type, LinkageSpec::Spec spec = LinkageSpec::Cforall ) : Parent( name, scs, type ) { set_linkage( spec ); }
+        TypedefDecl( const std::string &name, Type::StorageClasses scs, Type *type ) : Parent( name, scs, type ) {}
         TypedefDecl( const TypedefDecl &other ) : Parent( other ) {}
 …
         typedef Declaration Parent;
   public:
+        AggregateDecl( const std::string &name, const std::list< Attribute * > & attributes = std::list< class Attribute * >(), LinkageSpec::Spec linkage = LinkageSpec::Cforall );
+        AggregateDecl( const AggregateDecl &other );
+        virtual ~AggregateDecl();
+        std::list<Declaration*>& get_members() { return members; }
+        std::list<TypeDecl*>& get_parameters() { return parameters; }
+        std::list< Attribute * >& get_attributes() { return attributes; }
+        const std::list< Attribute * >& get_attributes() const { return attributes; }
+        bool has_body() const { return body; }
+        AggregateDecl * set_body( bool body ) { AggregateDecl::body = body; return this; }
+        virtual void print( std::ostream &os, int indent = 0 ) const;
+        virtual void printShort( std::ostream &os, int indent = 0 ) const;
+  protected:
+        virtual std::string typeString() const = 0;
+  private:
         std::list<Declaration*> members;
         std::list<TypeDecl*> parameters;
         bool body;
         std::list< Attribute * > attributes;
-        AggregateDecl( const std::string &name, const std::list< Attribute * > & attributes = std::list< class Attribute * >(), LinkageSpec::Spec linkage = LinkageSpec::Cforall );
-        AggregateDecl( const AggregateDecl &other );
-        virtual ~AggregateDecl();
-        std::list<Declaration*>& get_members() { return members; }
-        std::list<TypeDecl*>& get_parameters() { return parameters; }
-        std::list< Attribute * >& get_attributes() { return attributes; }
-        const std::list< Attribute * >& get_attributes() const { return attributes; }
-        bool has_body() const { return body; }
-        AggregateDecl * set_body( bool body ) { AggregateDecl::body = body; return this; }
-        virtual void print( std::ostream &os, int indent = 0 ) const;
-        virtual void printShort( std::ostream &os, int indent = 0 ) const;
-  protected:
-        virtual std::string typeString() const = 0;
 };
 …
         typedef AggregateDecl Parent;
   public:
+        StructDecl( const std::string &name, DeclarationNode::Aggregate kind = DeclarationNode::Struct, const std::list< Attribute * > & attributes = std::list< class Attribute * >(), LinkageSpec::Spec linkage = LinkageSpec::Cforall ) : Parent( name, attributes, linkage ), kind( kind ), tagged( false ), parent_name( "" ) {}
+        StructDecl( const std::string &name, const std::string *parent, const std::list< Attribute * > & attributes = std::list< class Attribute * >(), LinkageSpec::Spec linkage = LinkageSpec::Cforall ) : Parent( name, attributes, linkage ), kind( DeclarationNode::Struct ), tagged( true ), parent_name( parent ? *parent : "" ) {}
+        StructDecl( const std::string &name, DeclarationNode::Aggregate kind = DeclarationNode::Struct, const std::list< Attribute * > & attributes = std::list< class Attribute * >(), LinkageSpec::Spec linkage = LinkageSpec::Cforall ) : Parent( name, attributes, linkage ), kind( kind ) {}
         StructDecl( const StructDecl &other ) : Parent( other ) {}
 …
         bool is_thread() { return kind == DeclarationNode::Thread; }
-        // Tagged/Tree Structure Excetion
-        bool get_tagged() { return tagged; }
-        void set_tagged( bool newValue ) { tagged = newValue; }
-        bool has_parent() { return parent_name != ""; }
-        std::string get_parentName() { return parent_name; }
         virtual StructDecl *clone() const { return new StructDecl( *this ); }
         virtual void accept( Visitor &v ) { v.visit( this ); }
 …
         DeclarationNode::Aggregate kind;
         virtual std::string typeString() const;
-        bool tagged;
-        std::string parent_name;
 };
 …
 class AsmDecl : public Declaration {
   public:
-        AsmStmt *stmt;
         AsmDecl( AsmStmt *stmt );
         AsmDecl( const AsmDecl &other );
 …
         virtual void print( std::ostream &os, int indent = 0 ) const;
         virtual void printShort( std::ostream &os, int indent = 0 ) const;
+  private:
+        AsmStmt *stmt;
 };
 std::ostream & operator<<( std::ostream & out, const Declaration * decl );
 std::ostream & operator<<( std::ostream & os, const TypeDecl::Data & data );
+#endif // DECLARATION_H
 // Local Variables: //

src/SynTree/Expression.cc

-              r0720e049
+              r3d4b23fa
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Tue Jul 25 14:15:47 2017
 // Update Count     : 54
+// Last Modified On : Thu Mar 30 16:41:13 2017
+// Update Count     : 52
 //
 …
         if ( result->isVoid() ) {
                 os << "nothing";
-        } else {
-                result->print( os, indent+2 );
-        } // if
-        os << std::endl;
-        Expression::print( os, indent );
+}
-VirtualCastExpr::VirtualCastExpr( Expression *arg_, Type *toType ) : Expression(), arg(arg_) {
-        set_result(toType);
+}
-VirtualCastExpr::VirtualCastExpr( const VirtualCastExpr &other ) : Expression( other ), arg( maybeClone( other.arg ) ) {
+}
-VirtualCastExpr::~VirtualCastExpr() {
-        delete arg;
+}
-void VirtualCastExpr::print( std::ostream &os, int indent ) const {
-        os << "Virtual Cast of:" << std::endl << std::string( indent+2, ' ' );
-        arg->print(os, indent+2);
-        os << std::endl << std::string( indent, ' ' ) << "to:" << std::endl;
-        os << std::string( indent+2, ' ' );
-        if ( ! result ) {
-                os << "unknown";
         } else {
                 result->print( os, indent+2 );
 …
+}
 AsmExpr::AsmExpr( const AsmExpr & other ) : Expression( other ), inout( maybeClone( other.inout ) ), constraint( maybeClone( other.constraint ) ), operand( maybeClone( other.operand ) ) {}
+AsmExpr::AsmExpr( const AsmExpr & other ) : inout( maybeClone( other.inout ) ), constraint( maybeClone( other.constraint ) ), operand( maybeClone( other.operand ) ) {}

src/SynTree/Expression.h

-              r0720e049
+              r3d4b23fa
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Andrew Beach
 // Last Modified On : Fri Aug  8 11:54:00 2017
 // Update Count     : 44
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Thu Mar 30 16:44:00 2017
+// Update Count     : 41
 //
+#pragma once
+#ifndef EXPRESSION_H
+#define EXPRESSION_H
 #include <map>
 …
 class Expression : public BaseSyntaxNode{
   public:
-        Type * result;
-        TypeSubstitution * env;
-        Expression * argName; // if expression is used as an argument, it can be "designated" by this name
-        bool extension = false;
         Expression( Expression * _aname = nullptr );
         Expression( const Expression & other );
 …
         virtual Expression * acceptMutator( Mutator & m ) = 0;
         virtual void print( std::ostream & os, int indent = 0 ) const;
+  protected:
+        Type * result;
+        TypeSubstitution * env;
+        Expression * argName; // if expression is used as an argument, it can be "designated" by this name
+        bool extension = false;
 };
 …
 class ApplicationExpr : public Expression {
   public:
+        Expression * function;
+        ApplicationExpr( Expression * function, const std::list<Expression *> & args = std::list< Expression * >() );
+        ApplicationExpr( Expression * function );
         ApplicationExpr( const ApplicationExpr & other );
         virtual ~ApplicationExpr();
 …
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
+  private:
+  private:
+        Expression * function;
         std::list<Expression *> args;
         InferredParams inferParams;
 …
 class UntypedExpr : public Expression {
   public:
-        Expression * function;
-        std::list<Expression*> args;
         UntypedExpr( Expression * function, const std::list<Expression *> & args = std::list< Expression * >(), Expression *_aname = nullptr );
         UntypedExpr( const UntypedExpr & other );
 …
         virtual void print( std::ostream & os, int indent = 0 ) const;
         virtual void printArgs(std::ostream & os, int indent = 0) const;
+  private:
+        Expression * function;
+        std::list<Expression*> args;
 };
 …
 class NameExpr : public Expression {
   public:
-        std::string name;
         NameExpr( std::string name, Expression *_aname = nullptr );
         NameExpr( const NameExpr & other );
 …
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
+  private:
+        std::string name;
 };
 …
 class AddressExpr : public Expression {
   public:
-        Expression * arg;
         AddressExpr( Expression * arg, Expression *_aname = nullptr );
         AddressExpr( const AddressExpr & other );
 …
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
+  private:
+        Expression * arg;
 };
 …
 class LabelAddressExpr : public Expression {
   public:
-        Expression * arg;
         LabelAddressExpr( Expression * arg );
         LabelAddressExpr( const LabelAddressExpr & other );
 …
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
+  private:
+        Expression * arg;
 };
 …
 class CastExpr : public Expression {
   public:
-        Expression * arg;
         CastExpr( Expression * arg, Expression *_aname = nullptr );
         CastExpr( Expression * arg, Type * toType, Expression *_aname = nullptr );
 …
         Expression * get_arg() const { return arg; }
         void set_arg( Expression * newValue ) { arg = newValue; }
+        void set_arg(Expression * newValue ) { arg = newValue; }
         virtual CastExpr * clone() const { return new CastExpr( * this ); }
 …
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
+};
+/// VirtualCastExpr repersents a virtual dynamic cast, e.g. (virtual exception)e
+class VirtualCastExpr : public Expression {
+  public:
+  private:
         Expression * arg;
-        VirtualCastExpr( Expression * arg, Type * toType );
-        VirtualCastExpr( const VirtualCastExpr & other );
-        virtual ~VirtualCastExpr();
-        Expression * get_arg() const { return arg; }
-        void set_arg( Expression * newValue ) { arg = newValue; }
-        virtual VirtualCastExpr * clone() const { return new VirtualCastExpr( * this ); }
-        virtual void accept( Visitor & v ) { v.visit( this ); }
-        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
-        virtual void print( std::ostream & os, int indent = 0 ) const;
 };
 …
 class UntypedMemberExpr : public Expression {
   public:
-        Expression * member;
-        Expression * aggregate;
         UntypedMemberExpr( Expression * member, Expression * aggregate, Expression *_aname = nullptr );
         UntypedMemberExpr( const UntypedMemberExpr & other );
 …
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
+  private:
+        Expression * member;
+        Expression * aggregate;
 };
 …
 class MemberExpr : public Expression {
   public:
-        DeclarationWithType * member;
-        Expression * aggregate;
         MemberExpr( DeclarationWithType * member, Expression * aggregate, Expression *_aname = nullptr );
         MemberExpr( const MemberExpr & other );
 …
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
+  private:
+        DeclarationWithType * member;
+        Expression * aggregate;
 };
 …
 class VariableExpr : public Expression {
   public:
-        DeclarationWithType * var;
         VariableExpr( DeclarationWithType * var, Expression *_aname = nullptr );
         VariableExpr( const VariableExpr & other );
 …
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
+  private:
+        DeclarationWithType * var;
 };
 …
 class ConstantExpr : public Expression {
   public:
-        Constant constant;
         ConstantExpr( Constant constant, Expression *_aname = nullptr );
         ConstantExpr( const ConstantExpr & other );
 …
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
+  private:
+        Constant constant;
 };
 …
 class SizeofExpr : public Expression {
   public:
-        Expression * expr;
-        Type * type;
-        bool isType;
         SizeofExpr( Expression * expr, Expression *_aname = nullptr );
         SizeofExpr( const SizeofExpr & other );
 …
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
+};
+/// AlignofExpr represents an alignof expression
+class AlignofExpr : public Expression {
+  public:
+  private:
         Expression * expr;
         Type * type;
         bool isType;
+};
+/// AlignofExpr represents an alignof expression
+class AlignofExpr : public Expression {
+  public:
         AlignofExpr( Expression * expr, Expression *_aname = nullptr );
         AlignofExpr( const AlignofExpr & other );
 …
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
+  private:
+        Expression * expr;
+        Type * type;
+        bool isType;
 };
 …
 class UntypedOffsetofExpr : public Expression {
   public:
-        Type * type;
-        std::string member;
         UntypedOffsetofExpr( Type * type, const std::string & member, Expression *_aname = nullptr );
         UntypedOffsetofExpr( const UntypedOffsetofExpr & other );
 …
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
+  private:
+        Type * type;
+        std::string member;
 };
 …
 class OffsetofExpr : public Expression {
   public:
-        Type * type;
-        DeclarationWithType * member;
         OffsetofExpr( Type * type, DeclarationWithType * member, Expression *_aname = nullptr );
         OffsetofExpr( const OffsetofExpr & other );
 …
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
+  private:
+        Type * type;
+        DeclarationWithType * member;
 };
 …
 class OffsetPackExpr : public Expression {
 public:
-        StructInstType * type;
         OffsetPackExpr( StructInstType * type_, Expression * aname_ = 0 );
         OffsetPackExpr( const OffsetPackExpr & other );
 …
         virtual void accept( Visitor & v ) { v.visit( this ); }
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
+        virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual void print( std::ostream & os, int indent = 0 ) const;
+private:
+        StructInstType * type;
 };
 …
 class AttrExpr : public Expression {
   public:
-        Expression * attr;
-        Expression * expr;
-        Type * type;
-        bool isType;
         AttrExpr(Expression * attr, Expression * expr, Expression *_aname = nullptr );
         AttrExpr( const AttrExpr & other );
 …
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
+  private:
+        Expression * attr;
+        Expression * expr;
+        Type * type;
+        bool isType;
 };
 …
 class LogicalExpr : public Expression {
   public:
-        Expression * arg1;
-        Expression * arg2;
         LogicalExpr( Expression * arg1, Expression * arg2, bool andp = true, Expression *_aname = nullptr );
         LogicalExpr( const LogicalExpr & other );
 …
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
+  private:
+  private:
+        Expression * arg1;
+        Expression * arg2;
         bool isAnd;
 };
 …
 class ConditionalExpr : public Expression {
   public:
-        Expression * arg1;
-        Expression * arg2;
-        Expression * arg3;
         ConditionalExpr( Expression * arg1, Expression * arg2, Expression * arg3, Expression *_aname = nullptr );
         ConditionalExpr( const ConditionalExpr & other );
 …
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
+  private:
+        Expression * arg1;
+        Expression * arg2;
+        Expression * arg3;
 };
 …
 class CommaExpr : public Expression {
   public:
-        Expression * arg1;
-        Expression * arg2;
         CommaExpr( Expression * arg1, Expression * arg2, Expression *_aname = nullptr );
         CommaExpr( const CommaExpr & other );
 …
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
+  private:
+        Expression * arg1;
+        Expression * arg2;
 };
 …
 class TypeExpr : public Expression {
   public:
-        Type * type;
         TypeExpr( Type * type );
         TypeExpr( const TypeExpr & other );
 …
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
+  private:
+        Type * type;
 };
 …
 class AsmExpr : public Expression {
   public:
+        AsmExpr( Expression * inout, ConstantExpr * constraint, Expression * operand ) : inout( inout ), constraint( constraint ), operand( operand ) {}
+        AsmExpr( const AsmExpr & other );
+        virtual ~AsmExpr() { delete inout; delete constraint; delete operand; };
+        Expression * get_inout() const { return inout; }
+        void set_inout( Expression * newValue ) { inout = newValue; }
+        ConstantExpr * get_constraint() const { return constraint; }
+        void set_constraint( ConstantExpr * newValue ) { constraint = newValue; }
+        Expression * get_operand() const { return operand; }
+        void set_operand( Expression * newValue ) { operand = newValue; }
+        virtual AsmExpr * clone() const { return new AsmExpr( * this ); }
+        virtual void accept( Visitor & v ) { v.visit( this ); }
+        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
+        virtual void print( std::ostream & os, int indent = 0 ) const;
+  private:
+        // https://gcc.gnu.org/onlinedocs/gcc-4.7.1/gcc/Machine-Constraints.html#Machine-Constraints
         Expression * inout;
         ConstantExpr * constraint;
         Expression * operand;
-        AsmExpr( Expression * inout, ConstantExpr * constraint, Expression * operand ) : inout( inout ), constraint( constraint ), operand( operand ) {}
-        AsmExpr( const AsmExpr & other );
-        virtual ~AsmExpr() { delete inout; delete constraint; delete operand; };
-        Expression * get_inout() const { return inout; }
-        void set_inout( Expression * newValue ) { inout = newValue; }
-        ConstantExpr * get_constraint() const { return constraint; }
-        void set_constraint( ConstantExpr * newValue ) { constraint = newValue; }
-        Expression * get_operand() const { return operand; }
-        void set_operand( Expression * newValue ) { operand = newValue; }
-        virtual AsmExpr * clone() const { return new AsmExpr( * this ); }
-        virtual void accept( Visitor & v ) { v.visit( this ); }
-        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
-        virtual void print( std::ostream & os, int indent = 0 ) const;
-        // https://gcc.gnu.org/onlinedocs/gcc-4.7.1/gcc/Machine-Constraints.html#Machine-Constraints
 };
 …
 class ImplicitCopyCtorExpr : public Expression {
 public:
+        ImplicitCopyCtorExpr( ApplicationExpr * callExpr );
+        ImplicitCopyCtorExpr( const ImplicitCopyCtorExpr & other );
+        virtual ~ImplicitCopyCtorExpr();
+        ApplicationExpr * get_callExpr() const { return callExpr; }
+        void set_callExpr( ApplicationExpr * newValue ) { callExpr = newValue; }
+        std::list< ObjectDecl * > & get_tempDecls() { return tempDecls; }
+        std::list< ObjectDecl * > & get_returnDecls() { return returnDecls; }
+        std::list< Expression * > & get_dtors() { return dtors; }
+        virtual ImplicitCopyCtorExpr * clone() const { return new ImplicitCopyCtorExpr( * this ); }
+        virtual void accept( Visitor & v ) { v.visit( this ); }
+        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
+        virtual void print( std::ostream & os, int indent = 0 ) const;
+  private:
         ApplicationExpr * callExpr;
         std::list< ObjectDecl * > tempDecls;
         std::list< ObjectDecl * > returnDecls;
         std::list< Expression * > dtors;
-        ImplicitCopyCtorExpr( ApplicationExpr * callExpr );
-        ImplicitCopyCtorExpr( const ImplicitCopyCtorExpr & other );
-        virtual ~ImplicitCopyCtorExpr();
-        ApplicationExpr * get_callExpr() const { return callExpr; }
-        void set_callExpr( ApplicationExpr * newValue ) { callExpr = newValue; }
-        std::list< ObjectDecl * > & get_tempDecls() { return tempDecls; }
-        std::list< ObjectDecl * > & get_returnDecls() { return returnDecls; }
-        std::list< Expression * > & get_dtors() { return dtors; }
-        virtual ImplicitCopyCtorExpr * clone() const { return new ImplicitCopyCtorExpr( * this ); }
-        virtual void accept( Visitor & v ) { v.visit( this ); }
-        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
-        virtual void print( std::ostream & os, int indent = 0 ) const;
 };
 …
 class ConstructorExpr : public Expression {
 public:
-        Expression * callExpr;
         ConstructorExpr( Expression * callExpr );
         ConstructorExpr( const ConstructorExpr & other );
 …
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
+private:
+        Expression * callExpr;
 };
 …
 class CompoundLiteralExpr : public Expression {
   public:
-        Initializer * initializer;
         CompoundLiteralExpr( Type * type, Initializer * initializer );
         CompoundLiteralExpr( const CompoundLiteralExpr & other );
 …
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
+  private:
+        Initializer * initializer;
 };
 …
 class RangeExpr : public Expression {
   public:
-        Expression * low, * high;
         RangeExpr( Expression * low, Expression * high );
         RangeExpr( const RangeExpr & other );
 …
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
+  private:
+        Expression * low, * high;
 };
 …
 class UntypedTupleExpr : public Expression {
   public:
-        std::list<Expression*> exprs;
         UntypedTupleExpr( const std::list< Expression * > & exprs, Expression *_aname = nullptr );
         UntypedTupleExpr( const UntypedTupleExpr & other );
 …
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
+  private:
+        std::list<Expression*> exprs;
 };
 …
 class TupleExpr : public Expression {
   public:
-        std::list<Expression*> exprs;
         TupleExpr( const std::list< Expression * > & exprs, Expression *_aname = nullptr );
         TupleExpr( const TupleExpr & other );
 …
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
+  private:
+        std::list<Expression*> exprs;
 };
 …
 class TupleIndexExpr : public Expression {
   public:
-        Expression * tuple;
-        unsigned int index;
         TupleIndexExpr( Expression * tuple, unsigned int index );
         TupleIndexExpr( const TupleIndexExpr & other );
 …
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
+  private:
+        Expression * tuple;
+        unsigned int index;
 };
 …
 class TupleAssignExpr : public Expression {
   public:
-        StmtExpr * stmtExpr = nullptr;
         TupleAssignExpr( const std::list< Expression * > & assigns, const std::list< ObjectDecl * > & tempDecls, Expression * _aname = nullptr );
         TupleAssignExpr( const TupleAssignExpr & other );
 …
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
+  private:
+        StmtExpr * stmtExpr = nullptr;
 };
 …
 class StmtExpr : public Expression {
 public:
+        StmtExpr( CompoundStmt * statements );
+        StmtExpr( const StmtExpr & other );
+        virtual ~StmtExpr();
+        CompoundStmt * get_statements() const { return statements; }
+        StmtExpr * set_statements( CompoundStmt * newValue ) { statements = newValue; return this; }
+        std::list< ObjectDecl * > & get_returnDecls() { return returnDecls; }
+        std::list< Expression * > & get_dtors() { return dtors; }
+        virtual StmtExpr * clone() const { return new StmtExpr( * this ); }
+        virtual void accept( Visitor & v ) { v.visit( this ); }
+        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
+        virtual void print( std::ostream & os, int indent = 0 ) const;
+private:
         CompoundStmt * statements;
         std::list< ObjectDecl * > returnDecls; // return variable(s) for stmt expression
         std::list< Expression * > dtors; // destructor(s) for return variable(s)
-        StmtExpr( CompoundStmt * statements );
-        StmtExpr( const StmtExpr & other );
-        virtual ~StmtExpr();
-        CompoundStmt * get_statements() const { return statements; }
-        StmtExpr * set_statements( CompoundStmt * newValue ) { statements = newValue; return this; }
-        std::list< ObjectDecl * > & get_returnDecls() { return returnDecls; }
-        std::list< Expression * > & get_dtors() { return dtors; }
-        virtual StmtExpr * clone() const { return new StmtExpr( * this ); }
-        virtual void accept( Visitor & v ) { v.visit( this ); }
-        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
-        virtual void print( std::ostream & os, int indent = 0 ) const;
 };
 class UniqueExpr : public Expression {
 public:
+        UniqueExpr( Expression * expr, long long idVal = -1 );
+        UniqueExpr( const UniqueExpr & other );
+        ~UniqueExpr();
+        Expression * get_expr() const { return expr; }
+        UniqueExpr * set_expr( Expression * newValue ) { expr = newValue; return this; }
+        ObjectDecl * get_object() const { return object; }
+        UniqueExpr * set_object( ObjectDecl * newValue ) { object = newValue; return this; }
+        VariableExpr * get_var() const { return var; }
+        UniqueExpr * set_var( VariableExpr * newValue ) { var = newValue; return this; }
+        int get_id() const { return id; }
+        virtual UniqueExpr * clone() const { return new UniqueExpr( * this ); }
+        virtual void accept( Visitor & v ) { v.visit( this ); }
+        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
+        virtual void print( std::ostream & os, int indent = 0 ) const;
+private:
         Expression * expr;
         ObjectDecl * object;
         VariableExpr * var;
-        UniqueExpr( Expression * expr, long long idVal = -1 );
-        UniqueExpr( const UniqueExpr & other );
-        ~UniqueExpr();
-        Expression * get_expr() const { return expr; }
-        UniqueExpr * set_expr( Expression * newValue ) { expr = newValue; return this; }
-        ObjectDecl * get_object() const { return object; }
-        UniqueExpr * set_object( ObjectDecl * newValue ) { object = newValue; return this; }
-        VariableExpr * get_var() const { return var; }
-        UniqueExpr * set_var( VariableExpr * newValue ) { var = newValue; return this; }
-        int get_id() const { return id; }
-        virtual UniqueExpr * clone() const { return new UniqueExpr( * this ); }
-        virtual void accept( Visitor & v ) { v.visit( this ); }
-        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
-        virtual void print( std::ostream & os, int indent = 0 ) const;
-private:
         int id;
         static long long count;
 …
 class UntypedInitExpr : public Expression {
 public:
-        Expression * expr;
-        std::list<InitAlternative> initAlts;
         UntypedInitExpr( Expression * expr, const std::list<InitAlternative> & initAlts );
         UntypedInitExpr( const UntypedInitExpr & other );
 …
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
+private:
+        Expression * expr;
+        std::list<InitAlternative> initAlts;
 };
 class InitExpr : public Expression {
 public:
-        Expression * expr;
-        Designation * designation;
         InitExpr( Expression * expr, Designation * designation );
         InitExpr( const InitExpr & other );
 …
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
+private:
+        Expression * expr;
+        Designation * designation;
 };
 std::ostream & operator<<( std::ostream & out, const Expression * expr );
+#endif // EXPRESSION_H
 // Local Variables: //

src/SynTree/Initializer.cc

-              r0720e049
+              r3d4b23fa
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Andrew Beach
 // Last Modified On : Thr Aug  3 11:33:00 2016
 // Update Count     : 29
+// Last Modified By : Rob Schluntz
+// Last Modified On : Fri May 13 13:23:03 2016
+// Update Count     : 28
 //
 …
+                        }
+                }
                 assertf( initializers.size() == designations.size(), "Created ListInit with mismatching initializers (%lu) and designations (%lu)", initializers.size(), designations.size() );
+                assertf( initializers.size() == designations.size(), "Created ListInit with mismatching initializers (%d) and designations (%d)", initializers.size(), designations.size() );
+}

src/SynTree/Initializer.h

-              r0720e049
+              r3d4b23fa
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Andrew Beach
 // Last Modified On : Wed Aug  9 10:19:00 2017
 // Update Count     : 22
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Thu Mar 23 16:12:42 2017
+// Update Count     : 20
 //
+#pragma once
+#ifndef INITIALIZER_H
+#define INITIALIZER_H
 #include <cassert>
 …
 class Designation : public BaseSyntaxNode {
 public:
-        std::list< Expression * > designators;
         Designation( const std::list< Expression * > & designators );
         Designation( const Designation & other );
 …
         virtual Designation * acceptMutator( Mutator &m ) { return m.mutate( this ); }
         virtual void print( std::ostream &os, int indent = 0 ) const;
+private:
+        std::list< Expression * > designators;
 };
 …
 class SingleInit : public Initializer {
   public:
-        //Constant *value;
-        Expression *value;      // has to be a compile-time constant
         SingleInit( Expression *value, bool maybeConstructed = false );
         SingleInit( const SingleInit &other );
 …
         virtual Initializer *acceptMutator( Mutator &m ) { return m.mutate( this ); }
         virtual void print( std::ostream &os, int indent = 0 ) const;
+  private:
+        //Constant *value;
+        Expression *value;      // has to be a compile-time constant
 };
 …
 class ListInit : public Initializer {
   public:
-        std::list<Initializer *> initializers;  // order *is* important
-        std::list<Designation *> designations;  // order/length is consistent with initializers
         ListInit( const std::list<Initializer*> &initializers,
                           const std::list<Designation *> &designators = {}, bool maybeConstructed = false );
 …
         virtual Initializer *acceptMutator( Mutator &m ) { return m.mutate( this ); }
         virtual void print( std::ostream &os, int indent = 0 ) const;
+  private:
+        std::list<Initializer *> initializers;  // order *is* important
+        std::list<Designation *> designations;  // order/length is consistent with initializers
 };
 …
 class ConstructorInit : public Initializer {
   public:
-        Statement * ctor;
-        Statement * dtor;
         ConstructorInit( Statement * ctor, Statement * dtor, Initializer * init );
         ConstructorInit( const ConstructorInit &other );
 …
   private:
+        Statement * ctor;
+        Statement * dtor;
         // C-style initializer made up of SingleInit and ListInit nodes to use as a fallback
         // if an appropriate constructor definition is not found by the resolver
 …
 std::ostream & operator<<( std::ostream & out, const Designation * des );
+#endif // INITIALIZER_H
 // Local Variables: //
 // tab-width: 4 //

src/SynTree/Label.h

-              r0720e049
+              r3d4b23fa
 // Created On       : Wed Jun 8 12:53:12 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 09:52:44 2017
 // Update Count     : 3
+// Last Modified On : Sun Aug  7 14:44:29 2016
+// Update Count     : 2
 //
+#pragma once
+#ifndef LABEL_H
+#define LABEL_H
 #include <string>
 …
 static const std::list< Label > noLabels;
+#endif // LABEL_H
 // Local Variables: //
 // tab-width: 4 //

src/SynTree/Mutator.cc

-              r0720e049
+              r3d4b23fa
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Andrew Beach
 // Last Modified On : Mon Jul 24 16:32:00 2017
 // Update Count     : 25
+// Last Modified On : Thu Jun 22 13:43:00 2017
+// Update Count     : 24
 //
 …
+}
-Expression *Mutator::mutate( VirtualCastExpr *castExpr ) {
-        castExpr->set_env( maybeMutate( castExpr->get_env(), *this ) );
-        castExpr->set_result( maybeMutate( castExpr->get_result(), *this ) );
-        castExpr->set_arg( maybeMutate( castExpr->get_arg(), *this ) );
-        return castExpr;
+}
 Expression *Mutator::mutate( UntypedMemberExpr *memberExpr ) {
         memberExpr->set_env( maybeMutate( memberExpr->get_env(), *this ) );

src/SynTree/Mutator.h

-              r0720e049
+              r3d4b23fa
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Andrew Beach
 // Last Modified On : Mon Jul 24 16:31:00 2017
 // Update Count     : 16
+// Last Modified On : Thu Jun  8 15:45:00 2017
+// Update Count     : 14
 //
 #include <cassert>
 …
 #include "Common/SemanticError.h"
+#pragma once
+#ifndef MUTATOR_H
+#define MUTATOR_H
 class Mutator {
 …
         virtual Expression* mutate( LabelAddressExpr *labAddressExpr );
         virtual Expression* mutate( CastExpr *castExpr );
-        virtual Expression* mutate( VirtualCastExpr *castExpr );
         virtual Expression* mutate( UntypedMemberExpr *memberExpr );
         virtual Expression* mutate( MemberExpr *memberExpr );
 …
+}
+#endif // MUTATOR_H
 // Local Variables: //
 // tab-width: 4 //

src/SynTree/NamedTypeDecl.cc

-              r0720e049
+              r3d4b23fa
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Andrew Beach
 // Last Modified On : Wed Aug  9 13:28:00 2017
 // Update Count     : 14
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Thu Mar 16 07:49:44 2017
+// Update Count     : 13
 //
 …
         if ( get_name() != "" ) {
                 os << get_name() << ": ";
-        } // if
-        if ( get_linkage() != LinkageSpec::Cforall ) {
-                os << LinkageSpec::linkageName( get_linkage() ) << " ";
         } // if
         get_storageClasses().print( os );

src/SynTree/Statement.h

-              r0720e049
+              r3d4b23fa
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Andrew Beach
 // Last Modified On : Thr Aug  3 14:08:00 2017
 // Update Count     : 69
+// Last Modified On : Mon Jun 12 13:35:00 2017
+// Update Count     : 67
 //
+#pragma once
+#ifndef STATEMENT_H
+#define STATEMENT_H
 #include "BaseSyntaxNode.h"
 …
 class Statement : public BaseSyntaxNode {
   public:
-        std::list<Label> labels;
         Statement( std::list<Label> labels );
         virtual ~Statement();
 …
         virtual Statement *acceptMutator( Mutator &m ) = 0;
         virtual void print( std::ostream &os, int indent = 0 ) const;
+  protected:
+        std::list<Label> labels;
 };
 class CompoundStmt : public Statement {
   public:
-        std::list<Statement*> kids;
         CompoundStmt( std::list<Label> labels );
         CompoundStmt( const CompoundStmt &other );
 …
         virtual CompoundStmt *acceptMutator( Mutator &m ) { return m.mutate( this ); }
         virtual void print( std::ostream &os, int indent = 0 ) const;
+  private:
+        std::list<Statement*> kids;
 };
 …
         virtual NullStmt *acceptMutator( Mutator &m ) { return m.mutate( this ); }
         virtual void print( std::ostream &os, int indent = 0 ) const;
+  private:
 };
 class ExprStmt : public Statement {
   public:
-        Expression *expr;
         ExprStmt( std::list<Label> labels, Expression *expr );
         ExprStmt( const ExprStmt &other );
 …
         virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
         virtual void print( std::ostream &os, int indent = 0 ) const;
+  private:
+        Expression *expr;
 };
 class AsmStmt : public Statement {
   public:
-        bool voltile;
-        ConstantExpr *instruction;
-        std::list<Expression *> output, input;
-        std::list<ConstantExpr *> clobber;
-        std::list<Label> gotolabels;
         AsmStmt( std::list<Label> labels, bool voltile, ConstantExpr *instruction, std::list<Expression *> input, std::list<Expression *> output, std::list<ConstantExpr *> clobber, std::list<Label> gotolabels );
         AsmStmt( const AsmStmt &other );
 …
         virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
         virtual void print( std::ostream &os, int indent = 0 ) const;
+  private:
+        bool voltile;
+        ConstantExpr *instruction;
+        std::list<Expression *> output, input;
+        std::list<ConstantExpr *> clobber;
+        std::list<Label> gotolabels;
 };
 class IfStmt : public Statement {
   public:
-        Expression *condition;
-        Statement *thenPart;
-        Statement *elsePart;
         IfStmt( std::list<Label> labels, Expression *condition, Statement *thenPart, Statement *elsePart );
         IfStmt( const IfStmt &other );
 …
         virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
         virtual void print( std::ostream &os, int indent = 0 ) const;
+  private:
+        Expression *condition;
+        Statement *thenPart;
+        Statement *elsePart;
 };
 class SwitchStmt : public Statement {
   public:
-        Expression * condition;
         SwitchStmt( std::list<Label> labels, Expression *condition, std::list<Statement *> &statements );
         SwitchStmt( const SwitchStmt &other );
 …
         virtual void print( std::ostream &os, int indent = 0 ) const;
   private:
+        Expression * condition;
         std::list<Statement *> statements;
 };
 …
 class CaseStmt : public Statement {
   public:
-        Expression * condition;
-        std::list<Statement *> stmts;
         CaseStmt( std::list<Label> labels, Expression *conditions, std::list<Statement *> &stmts, bool isdef = false ) throw(SemanticError);
         CaseStmt( const CaseStmt &other );
 …
         virtual void print( std::ostream &os, int indent = 0 ) const;
   private:
+        Expression * condition;
+        std::list<Statement *> stmts;
         bool _isDefault;
 };
 …
 class WhileStmt : public Statement {
   public:
-        Expression *condition;
-        Statement *body;
-        bool isDoWhile;
         WhileStmt( std::list<Label> labels, Expression *condition,
                Statement *body, bool isDoWhile = false );
 …
         virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
         virtual void print( std::ostream &os, int indent = 0 ) const;
+  private:
+        Expression *condition;
+        Statement *body;
+        bool isDoWhile;
 };
 class ForStmt : public Statement {
   public:
-        std::list<Statement *> initialization;
-        Expression *condition;
-        Expression *increment;
-        Statement *body;
         ForStmt( std::list<Label> labels, std::list<Statement *> initialization,
              Expression *condition = 0, Expression *increment = 0, Statement *body = 0 );
 …
         virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
         virtual void print( std::ostream &os, int indent = 0 ) const;
+  private:
+        std::list<Statement *> initialization;
+        Expression *condition;
+        Expression *increment;
+        Statement *body;
 };
 …
         enum Type { Goto = 0, Break, Continue };
+        // originalTarget kept for error messages.
+        const Label originalTarget;
+        BranchStmt( std::list<Label> labels, Label target, Type ) throw (SemanticError);
+        BranchStmt( std::list<Label> labels, Expression *computedTarget, Type ) throw (SemanticError);
+        Label get_originalTarget() { return originalTarget; }
+        Label get_target() { return target; }
+        void set_target( Label newValue ) { target = newValue; }
+        Expression *get_computedTarget() { return computedTarget; }
+        void set_target( Expression * newValue ) { computedTarget = newValue; }
+        Type get_type() { return type; }
+        const char *get_typename() { return brType[ type ]; }
+        virtual BranchStmt *clone() const { return new BranchStmt( *this ); }
+        virtual void accept( Visitor &v ) { v.visit( this ); }
+        virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+        virtual void print( std::ostream &os, int indent = 0 ) const;
+  private:
+        static const char *brType[];
+        Label originalTarget;  // can give better error messages if we remember the label name that the user entered
         Label target;
         Expression *computedTarget;
         Type type;
-        BranchStmt( std::list<Label> labels, Label target, Type ) throw (SemanticError);
-        BranchStmt( std::list<Label> labels, Expression *computedTarget, Type ) throw (SemanticError);
-        Label get_originalTarget() { return originalTarget; }
-        Label get_target() { return target; }
-        void set_target( Label newValue ) { target = newValue; }
-        Expression *get_computedTarget() { return computedTarget; }
-        void set_target( Expression * newValue ) { computedTarget = newValue; }
-        Type get_type() { return type; }
-        const char *get_typename() { return brType[ type ]; }
-        virtual BranchStmt *clone() const { return new BranchStmt( *this ); }
-        virtual void accept( Visitor &v ) { v.visit( this ); }
-        virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
-        virtual void print( std::ostream &os, int indent = 0 ) const;
-  private:
-        static const char *brType[];
 };
 class ReturnStmt : public Statement {
   public:
-        Expression *expr;
         ReturnStmt( std::list<Label> labels, Expression *expr );
         ReturnStmt( const ReturnStmt &other );
 …
         virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
         virtual void print( std::ostream &os, int indent = 0 ) const;
+  private:
+        Expression *expr;
 };
 …
   public:
         enum Kind { Terminate, Resume };
-        const Kind kind;
-        Expression * expr;
-        Expression * target;
         ThrowStmt( std::list<Label> labels, Kind kind, Expression * expr, Expression * target = nullptr );
 …
         virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
         virtual void print( std::ostream &os, int indent = 0 ) const;
+  private:
+        Kind kind;
+        Expression * expr;
+        Expression * target;
 };
 class TryStmt : public Statement {
   public:
+        TryStmt( std::list<Label> labels, CompoundStmt *tryBlock, std::list<CatchStmt *> &handlers, FinallyStmt *finallyBlock = 0 );
+        TryStmt( const TryStmt &other );
+        virtual ~TryStmt();
+        CompoundStmt *get_block() const { return block; }
+        void set_block( CompoundStmt *newValue ) { block = newValue; }
+        std::list<CatchStmt *>& get_catchers() { return handlers; }
+        FinallyStmt *get_finally() const { return finallyBlock; }
+        void set_finally( FinallyStmt *newValue ) { finallyBlock = newValue; }
+        virtual TryStmt *clone() const { return new TryStmt( *this ); }
+        virtual void accept( Visitor &v ) { v.visit( this ); }
+        virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+        virtual void print( std::ostream &os, int indent = 0 ) const;
+  private:
         CompoundStmt *block;
         std::list<CatchStmt *> handlers;
         FinallyStmt *finallyBlock;
-        TryStmt( std::list<Label> labels, CompoundStmt *tryBlock, std::list<CatchStmt *> &handlers, FinallyStmt *finallyBlock = 0 );
-        TryStmt( const TryStmt &other );
-        virtual ~TryStmt();
-        CompoundStmt *get_block() const { return block; }
-        void set_block( CompoundStmt *newValue ) { block = newValue; }
-        std::list<CatchStmt *>& get_catchers() { return handlers; }
-        FinallyStmt *get_finally() const { return finallyBlock; }
-        void set_finally( FinallyStmt *newValue ) { finallyBlock = newValue; }
-        virtual TryStmt *clone() const { return new TryStmt( *this ); }
-        virtual void accept( Visitor &v ) { v.visit( this ); }
-        virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
-        virtual void print( std::ostream &os, int indent = 0 ) const;
 };
 …
   public:
         enum Kind { Terminate, Resume };
-        const Kind kind;
-        Declaration *decl;
-        Expression *cond;
-        Statement *body;
         CatchStmt( std::list<Label> labels, Kind kind, Declaration *decl,
 …
         virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
         virtual void print( std::ostream &os, int indent = 0 ) const;
+  private:
+        Kind kind;
+        Declaration *decl;
+        Expression *cond;
+        Statement *body;
 };
 class FinallyStmt : public Statement {
   public:
-        CompoundStmt *block;
         FinallyStmt( std::list<Label> labels, CompoundStmt *block );
         FinallyStmt( const FinallyStmt &other );
 …
         virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
         virtual void print( std::ostream &os, int indent = 0 ) const;
+  private:
+        CompoundStmt *block;
 };
 …
 class DeclStmt : public Statement {
   public:
-        Declaration *decl;
         DeclStmt( std::list<Label> labels, Declaration *decl );
         DeclStmt( const DeclStmt &other );
 …
         virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
         virtual void print( std::ostream &os, int indent = 0 ) const;
+  private:
+        Declaration *decl;
 };
 …
 class ImplicitCtorDtorStmt : public Statement {
   public:
-        // Non-owned pointer to the constructor/destructor statement
-        Statement * callStmt;
         ImplicitCtorDtorStmt( Statement * callStmt );
         ImplicitCtorDtorStmt( const ImplicitCtorDtorStmt & other );
 …
         virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
         virtual void print( std::ostream &os, int indent = 0 ) const;
+  private:
+        // Non-owned pointer to the constructor/destructor statement
+        Statement * callStmt;
 };
 std::ostream & operator<<( std::ostream & out, const Statement * statement );
+#endif // STATEMENT_H
 // Local Variables: //

src/SynTree/SynTree.h

-              r0720e049
+              r3d4b23fa
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Andrew Beach
 // Last Modified On : Mon Jul 24 16:54:00 2017
 // Update Count     : 11
+// Last Modified On : Thu Jun  8 17:00:00 2017
+// Update Count     : 9
 //
+#pragma once
+#ifndef SYNTREE_H
+#define SYNTREE_H
 #include <string>
 …
 class LabelAddressExpr;
 class CastExpr;
-class VirtualCastExpr;
 class MemberExpr;
 class UntypedMemberExpr;
 …
 class Attribute;
+#endif // SYNTREE_H
 // Local Variables: //
 // tab-width: 4 //

src/SynTree/Type.cc

-              r0720e049
+              r3d4b23fa
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Andrew Beach
 // Last Modified On : Wed Aug  2 11:11:00 2017
 // Update Count     : 29
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Fri Mar 17 08:42:47 2017
+// Update Count     : 28
 //
 …
+}
-// Empty Variable declarations:
-const Type::FuncSpecifiers noFuncSpecifiers;
-const Type::StorageClasses noStorageClasses;
-const Type::Qualifiers noQualifiers;
 std::ostream & operator<<( std::ostream & out, const Type * type ) {
         if ( type ) {

src/SynTree/Type.h

-              r0720e049
+              r3d4b23fa
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Andrew Beach
 // Last Modified On : Wed Aug  9 14:25:00 2017
 // Update Count     : 152
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Thu Mar 23 16:16:36 2017
+// Update Count     : 149
 //
+#pragma once
+#ifndef TYPE_H
+#define TYPE_H
 #include "BaseSyntaxNode.h"
 …
         }; // Qualifiers
-        typedef std::list<TypeDecl *> ForallList;
-        Qualifiers tq;
-        ForallList forall;
-        std::list< Attribute * > attributes;
         Type( const Qualifiers & tq, const std::list< Attribute * > & attributes );
         Type( const Type & other );
 …
         void set_atomic( bool newValue ) { tq.is_atomic = newValue; }
+        typedef std::list<TypeDecl *> ForallList;
         ForallList& get_forall() { return forall; }
 …
         virtual Type *acceptMutator( Mutator & m ) = 0;
         virtual void print( std::ostream & os, int indent = 0 ) const;
+};
+extern const Type::FuncSpecifiers noFuncSpecifiers;
+extern const Type::StorageClasses noStorageClasses;
+extern const Type::Qualifiers noQualifiers;                     // no qualifiers on constants
+  private:
+        Qualifiers tq;
+        ForallList forall;
+        std::list< Attribute * > attributes;
+};
+extern Type::Qualifiers emptyQualifiers;                                // no qualifiers on constants
 class VoidType : public Type {
 …
                 LongDoubleImaginary,
                 NUMBER_OF_BASIC_TYPES
         } kind;
+        };
         static const char *typeNames[];                                         // string names for basic types, MUST MATCH with Kind
 …
         bool isInteger() const;
+  private:
+        Kind kind;
 };
 class PointerType : public Type {
   public:
-        Type *base;
-        // In C99, pointer types can be qualified in many ways e.g., int f( int a[ static 3 ] )
-        Expression *dimension;
-        bool isVarLen;
-        bool isStatic;
         PointerType( const Type::Qualifiers & tq, Type *base, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
         PointerType( const Type::Qualifiers & tq, Type *base, Expression *dimension, bool isVarLen, bool isStatic, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
 …
         virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
+};
+class ArrayType : public Type {
+  public:
+  private:
         Type *base;
+        // In C99, pointer types can be qualified in many ways e.g., int f( int a[ static 3 ] )
         Expression *dimension;
         bool isVarLen;
         bool isStatic;
+};
+class ArrayType : public Type {
+  public:
         ArrayType( const Type::Qualifiers & tq, Type *base, Expression *dimension, bool isVarLen, bool isStatic, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
         ArrayType( const ArrayType& );
 …
         virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
+  private:
+        Type *base;
+        Expression *dimension;
+        bool isVarLen;
+        bool isStatic;
 };
 class FunctionType : public Type {
   public:
+        FunctionType( const Type::Qualifiers & tq, bool isVarArgs, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
+        FunctionType( const FunctionType& );
+        virtual ~FunctionType();
+        std::list<DeclarationWithType*> & get_returnVals() { return returnVals; }
+        std::list<DeclarationWithType*> & get_parameters() { return parameters; }
+        bool get_isVarArgs() const { return isVarArgs; }
+        void set_isVarArgs( bool newValue ) { isVarArgs = newValue; }
+        bool isTtype() const;
+        virtual FunctionType *clone() const { return new FunctionType( *this ); }
+        virtual void accept( Visitor & v ) { v.visit( this ); }
+        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
+        virtual void print( std::ostream & os, int indent = 0 ) const;
+  private:
         std::list<DeclarationWithType*> returnVals;
         std::list<DeclarationWithType*> parameters;
 …
         // - an unprototyped declaration
         bool isVarArgs;
-        FunctionType( const Type::Qualifiers & tq, bool isVarArgs, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
-        FunctionType( const FunctionType& );
-        virtual ~FunctionType();
-        std::list<DeclarationWithType*> & get_returnVals() { return returnVals; }
-        std::list<DeclarationWithType*> & get_parameters() { return parameters; }
-        bool get_isVarArgs() const { return isVarArgs; }
-        void set_isVarArgs( bool newValue ) { isVarArgs = newValue; }
-        bool isTtype() const;
-        virtual FunctionType *clone() const { return new FunctionType( *this ); }
-        virtual void accept( Visitor & v ) { v.visit( this ); }
-        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
-        virtual void print( std::ostream & os, int indent = 0 ) const;
 };
 class ReferenceToType : public Type {
   public:
-        std::list< Expression* > parameters;
-        std::string name;
-        bool hoistType;
         ReferenceToType( const Type::Qualifiers & tq, const std::string & name, const std::list< Attribute * > & attributes );
         ReferenceToType( const ReferenceToType & other );
 …
   protected:
         virtual std::string typeString() const = 0;
+        std::list< Expression* > parameters;
+        std::string name;
+  private:
+        bool hoistType;
 };
 …
         typedef ReferenceToType Parent;
   public:
+        StructInstType( const Type::Qualifiers & tq, const std::string & name, const std::list< Attribute * > & attributes = std::list< Attribute * >()  ) : Parent( tq, name, attributes ), baseStruct( 0 ) {}
+        StructInstType( const Type::Qualifiers & tq, StructDecl * baseStruct, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
+        StructInstType( const StructInstType & other ) : Parent( other ), baseStruct( other.baseStruct ) {}
+        StructDecl *get_baseStruct() const { return baseStruct; }
+        void set_baseStruct( StructDecl *newValue ) { baseStruct = newValue; }
+        /// Accesses generic parameters of base struct (NULL if none such)
+        std::list<TypeDecl*> * get_baseParameters();
+        virtual bool isComplete() const;
+        /// Looks up the members of this struct named "name" and places them into "foundDecls".
+        /// Clones declarations into "foundDecls", caller responsible for freeing
+        void lookup( const std::string & name, std::list< Declaration* > & foundDecls ) const;
+        virtual StructInstType *clone() const { return new StructInstType( *this ); }
+        virtual void accept( Visitor & v ) { v.visit( this ); }
+        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
+        virtual void print( std::ostream & os, int indent = 0 ) const;
+  private:
+        virtual std::string typeString() const;
         // this decl is not "owned" by the struct inst; it is merely a pointer to elsewhere in the tree,
         // where the structure used in this type is actually defined
         StructDecl *baseStruct;
+        StructInstType( const Type::Qualifiers & tq, const std::string & name, const std::list< Attribute * > & attributes = std::list< Attribute * >()  ) : Parent( tq, name, attributes ), baseStruct( 0 ) {}
+        StructInstType( const Type::Qualifiers & tq, StructDecl * baseStruct, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
+        StructInstType( const StructInstType & other ) : Parent( other ), baseStruct( other.baseStruct ) {}
+        StructDecl *get_baseStruct() const { return baseStruct; }
+        void set_baseStruct( StructDecl *newValue ) { baseStruct = newValue; }
+        /// Accesses generic parameters of base struct (NULL if none such)
+        std::list<TypeDecl*> * get_baseParameters();
+};
+class UnionInstType : public ReferenceToType {
+        typedef ReferenceToType Parent;
+  public:
+        UnionInstType( const Type::Qualifiers & tq, const std::string & name, const std::list< Attribute * > & attributes = std::list< Attribute * >()  ) : Parent( tq, name, attributes ), baseUnion( 0 ) {}
+        UnionInstType( const Type::Qualifiers & tq, UnionDecl * baseUnion, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
+        UnionInstType( const UnionInstType & other ) : Parent( other ), baseUnion( other.baseUnion ) {}
+        UnionDecl *get_baseUnion() const { return baseUnion; }
+        void set_baseUnion( UnionDecl * newValue ) { baseUnion = newValue; }
+        /// Accesses generic parameters of base union (NULL if none such)
+        std::list< TypeDecl * > * get_baseParameters();
         virtual bool isComplete() const;
         /// Looks up the members of this struct named "name" and places them into "foundDecls".
+        /// looks up the members of this union named "name" and places them into "foundDecls"
         /// Clones declarations into "foundDecls", caller responsible for freeing
         void lookup( const std::string & name, std::list< Declaration* > & foundDecls ) const;
         virtual StructInstType *clone() const { return new StructInstType( *this ); }
+        virtual UnionInstType *clone() const { return new UnionInstType( *this ); }
         virtual void accept( Visitor & v ) { v.visit( this ); }
         virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
 …
   private:
         virtual std::string typeString() const;
+};
+class UnionInstType : public ReferenceToType {
+        typedef ReferenceToType Parent;
+  public:
         // this decl is not "owned" by the union inst; it is merely a pointer to elsewhere in the tree,
         // where the union used in this type is actually defined
         UnionDecl *baseUnion;
-        UnionInstType( const Type::Qualifiers & tq, const std::string & name, const std::list< Attribute * > & attributes = std::list< Attribute * >()  ) : Parent( tq, name, attributes ), baseUnion( 0 ) {}
-        UnionInstType( const Type::Qualifiers & tq, UnionDecl * baseUnion, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
-        UnionInstType( const UnionInstType & other ) : Parent( other ), baseUnion( other.baseUnion ) {}
-        UnionDecl *get_baseUnion() const { return baseUnion; }
-        void set_baseUnion( UnionDecl * newValue ) { baseUnion = newValue; }
-        /// Accesses generic parameters of base union (NULL if none such)
-        std::list< TypeDecl * > * get_baseParameters();
-        virtual bool isComplete() const;
-        /// looks up the members of this union named "name" and places them into "foundDecls"
-        /// Clones declarations into "foundDecls", caller responsible for freeing
-        void lookup( const std::string & name, std::list< Declaration* > & foundDecls ) const;
-        virtual UnionInstType *clone() const { return new UnionInstType( *this ); }
-        virtual void accept( Visitor & v ) { v.visit( this ); }
-        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
-        virtual void print( std::ostream & os, int indent = 0 ) const;
-  private:
-        virtual std::string typeString() const;
 };
 …
         typedef ReferenceToType Parent;
   public:
+        EnumInstType( const Type::Qualifiers & tq, const std::string & name, const std::list< Attribute * > & attributes = std::list< Attribute * >()  ) : Parent( tq, name, attributes ) {}
+        EnumInstType( const Type::Qualifiers & tq, EnumDecl * baseEnum, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
+        EnumInstType( const EnumInstType & other ) : Parent( other ), baseEnum( other.baseEnum ) {}
+        EnumDecl *get_baseEnum() const { return baseEnum; }
+        void set_baseEnum( EnumDecl *newValue ) { baseEnum = newValue; }
+        virtual bool isComplete() const;
+        virtual EnumInstType *clone() const { return new EnumInstType( *this ); }
+        virtual void accept( Visitor & v ) { v.visit( this ); }
+        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
+  private:
+        virtual std::string typeString() const;
         // this decl is not "owned" by the union inst; it is merely a pointer to elsewhere in the tree,
         // where the union used in this type is actually defined
         EnumDecl *baseEnum = nullptr;
-        EnumInstType( const Type::Qualifiers & tq, const std::string & name, const std::list< Attribute * > & attributes = std::list< Attribute * >()  ) : Parent( tq, name, attributes ) {}
-        EnumInstType( const Type::Qualifiers & tq, EnumDecl * baseEnum, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
-        EnumInstType( const EnumInstType & other ) : Parent( other ), baseEnum( other.baseEnum ) {}
-        EnumDecl *get_baseEnum() const { return baseEnum; }
-        void set_baseEnum( EnumDecl *newValue ) { baseEnum = newValue; }
-        virtual bool isComplete() const;
-        virtual EnumInstType *clone() const { return new EnumInstType( *this ); }
-        virtual void accept( Visitor & v ) { v.visit( this ); }
-        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
-  private:
-        virtual std::string typeString() const;
 };
 …
         typedef ReferenceToType Parent;
   public:
+        TraitInstType( const Type::Qualifiers & tq, const std::string & name, const std::list< Attribute * > & attributes = std::list< Attribute * >()  ) : Parent( tq, name, attributes ) {}
+        TraitInstType( const TraitInstType & other );
+        ~TraitInstType();
+        std::list< Declaration* >& get_members() { return members; }
+        virtual bool isComplete() const;
+        virtual TraitInstType *clone() const { return new TraitInstType( *this ); }
+        virtual void accept( Visitor & v ) { v.visit( this ); }
+        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
+  private:
+        virtual std::string typeString() const;
         // this member is filled in by the validate pass, which instantiates the members of the correponding
         // aggregate with the actual type parameters specified for this use of the context
         std::list< Declaration* > members;
-        TraitInstType( const Type::Qualifiers & tq, const std::string & name, const std::list< Attribute * > & attributes = std::list< Attribute * >()  ) : Parent( tq, name, attributes ) {}
-        TraitInstType( const TraitInstType & other );
-        ~TraitInstType();
-        std::list< Declaration* >& get_members() { return members; }
-        virtual bool isComplete() const;
-        virtual TraitInstType *clone() const { return new TraitInstType( *this ); }
-        virtual void accept( Visitor & v ) { v.visit( this ); }
-        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
-  private:
-        virtual std::string typeString() const;
 };
 …
         typedef ReferenceToType Parent;
   public:
+        TypeInstType( const Type::Qualifiers & tq, const std::string & name, TypeDecl *baseType, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
+        TypeInstType( const Type::Qualifiers & tq, const std::string & name, bool isFtype, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
+        TypeInstType( const TypeInstType & other );
+        ~TypeInstType();
+        TypeDecl *get_baseType() const { return baseType; }
+        void set_baseType( TypeDecl *newValue );
+        bool get_isFtype() const { return isFtype; }
+        void set_isFtype( bool newValue ) { isFtype = newValue; }
+        virtual bool isComplete() const;
+        virtual TypeInstType *clone() const { return new TypeInstType( *this ); }
+        virtual void accept( Visitor & v ) { v.visit( this ); }
+        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
+        virtual void print( std::ostream & os, int indent = 0 ) const;
+  private:
+        virtual std::string typeString() const;
         // this decl is not "owned" by the type inst; it is merely a pointer to elsewhere in the tree,
         // where the type used here is actually defined
         TypeDecl *baseType;
         bool isFtype;
-        TypeInstType( const Type::Qualifiers & tq, const std::string & name, TypeDecl *baseType, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
-        TypeInstType( const Type::Qualifiers & tq, const std::string & name, bool isFtype, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
-        TypeInstType( const TypeInstType & other );
-        ~TypeInstType();
-        TypeDecl *get_baseType() const { return baseType; }
-        void set_baseType( TypeDecl *newValue );
-        bool get_isFtype() const { return isFtype; }
-        void set_isFtype( bool newValue ) { isFtype = newValue; }
-        virtual bool isComplete() const;
-        virtual TypeInstType *clone() const { return new TypeInstType( *this ); }
-        virtual void accept( Visitor & v ) { v.visit( this ); }
-        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
-        virtual void print( std::ostream & os, int indent = 0 ) const;
-  private:
-        virtual std::string typeString() const;
 };
 class TupleType : public Type {
   public:
-        std::list<Type *> types;
-        std::list<Declaration *> members;
         TupleType( const Type::Qualifiers & tq, const std::list< Type * > & types, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
         TupleType( const TupleType& );
 …
         virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
+  private:
+        std::list<Type *> types;
+        std::list<Declaration *> members;
 };
 class TypeofType : public Type {
   public:
-        Expression *expr;
         TypeofType( const Type::Qualifiers & tq, Expression *expr, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
         TypeofType( const TypeofType& );
 …
         virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
+  private:
+        Expression *expr;
 };
 class AttrType : public Type {
   public:
-        std::string name;
-        Expression *expr;
-        Type *type;
-        bool isType;
         AttrType( const Type::Qualifiers & tq, const std::string & name, Expression *expr, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
         AttrType( const Type::Qualifiers & tq, const std::string & name, Type *type, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
 …
         virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
+  private:
+        std::string name;
+        Expression *expr;
+        Type *type;
+        bool isType;
 };
 …
 std::ostream & operator<<( std::ostream & out, const Type * type );
+#endif // TYPE_H
 // Local Variables: //

src/SynTree/TypeDecl.cc

-              r0720e049
+              r3d4b23fa
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Andrew Beach
 // Last Modified On : Wed Aug  9 14:35:00 2017
 // Update Count     : 6
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Thu Mar 16 07:49:58 2017
+// Update Count     : 5
 //
 …
 #include "Common/utility.h"
 TypeDecl::TypeDecl( const std::string &name, Type::StorageClasses scs, Type *type, Kind kind, Type * init ) : Parent( name, scs, type ), init( init ), sized( kind == Any || kind == Ttype ), kind( kind ) {
+TypeDecl::TypeDecl( const std::string &name, Type::StorageClasses scs, Type *type, Kind kind, Type * init ) : Parent( name, scs, type ), kind( kind ), init( init ), sized( kind == Any || kind == Ttype ) {
+}
 TypeDecl::TypeDecl( const TypeDecl &other ) : Parent( other ), init( maybeClone( other.init ) ), sized( other.sized ), kind( other.kind ) {
+TypeDecl::TypeDecl( const TypeDecl &other ) : Parent( other ), kind( other.kind ), init( maybeClone( other.init ) ), sized( other.sized ) {
+}

src/SynTree/TypeExpr.cc

r0720e049	r3d4b23fa
21	21	}
22	22
23		TypeExpr::TypeExpr( const TypeExpr &other ) : ~~Expression( other ),~~ type( maybeClone( other.type ) ) {
	23	TypeExpr::TypeExpr( const TypeExpr &other ) : type( maybeClone( other.type ) ) {
24	24	}
25	25

src/SynTree/TypeSubstitution.h

-              r0720e049
+              r3d4b23fa
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 09:52:24 2017
 // Update Count     : 3
+// Last Modified By : Rob Schluntz
+// Last Modified On : Fri Apr 29 15:00:20 2016
+// Update Count     : 2
 //
+#pragma once
+#ifndef TYPESUBSTITUTION_H
+#define TYPESUBSTITUTION_H
 #include <map>
 …
 std::ostream & operator<<( std::ostream & out, const TypeSubstitution & sub );
+#endif // TYPESUBSTITUTION_H
 // Local Variables: //
 // tab-width: 4 //

src/SynTree/VarExprReplacer.h

-              r0720e049
+              r3d4b23fa
 // Author           : Rob Schluntz
 // Created On       : Wed Jan 13 16:29:30 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 09:53:41 2017
 // Update Count     : 6
+// Last Modified By : Rob Schluntz
+// Last Modified On : Fri May 13 11:27:52 2016
+// Update Count     : 5
 //
+#pragma once
+#ifndef VAR_EXPR_REPLACER_H
+#define VAR_EXPR_REPLACER_H
 #include <map>
 …
 };
+#endif // VAR_EXPR_REPLACER_H
 // Local Variables: //
 // tab-width: 4 //

src/SynTree/Visitor.cc

-              r0720e049
+              r3d4b23fa
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Andrew Beach
 // Last Modified On : Mon Jul 24 16:30:00 2017
 // Update Count     : 27
+// Last Modified On : Thu Jun 22 13:41:00 2017
+// Update Count     : 26
 //
 …
+}
-void Visitor::visit( VirtualCastExpr *castExpr ) {
-        maybeAccept( castExpr->get_result(), *this );
-        maybeAccept( castExpr->get_arg(), *this );
+}
 void Visitor::visit( UntypedMemberExpr *memberExpr ) {
         maybeAccept( memberExpr->get_result(), *this );

src/SynTree/Visitor.h

-              r0720e049
+              r3d4b23fa
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Andrew Beach
 // Last Modified On : Mon Jul 24 16:28:00 2017
 // Update Count     : 13
+// Last Modified On : Thr Jun 08 15:45:00 2017
+// Update Count     : 11
 //
+#pragma once
+#ifndef VISITOR_H
+#define VISITOR_H
 #include "SynTree.h"
 …
         virtual void visit( NameExpr *nameExpr );
         virtual void visit( CastExpr *castExpr );
-        virtual void visit( VirtualCastExpr *castExpr );
         virtual void visit( AddressExpr *addressExpr );
         virtual void visit( LabelAddressExpr *labAddressExpr );
 …
+}
+#endif // VISITOR_H
 // Local Variables: //
 // tab-width: 4 //

src/Tuples/Explode.h

-              r0720e049
+              r3d4b23fa
 // Author           : Rob Schluntz
 // Created On       : Wed Nov 9 13:12:24 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 09:55:16 2017
 // Update Count     : 3
+// Last Modified By : Rob Schluntz
+// Last Modified On : Wed Nov 9 13:20:24 2016
+// Update Count     : 2
 //
+#pragma once
+#ifndef _EXPLODE_H_
+#define _EXPLODE_H_
 #include "ResolvExpr/AlternativeFinder.h"
 …
 } // namespace Tuples
+#endif // _TUPLE_ASSIGNMENT_H_
 // Local Variables: //
 // tab-width: 4 //

src/Tuples/TupleExpansion.cc

-              r0720e049
+              r3d4b23fa
                 };
+                struct TupleTypeReplacer : public WithDeclsToAdd, public WithGuards, public WithTypeSubstitution {
+                        Type * postmutate( TupleType * tupleType );
+                        void premutate( CompoundStmt * ) {
+                                GuardScope( typeMap );
+                class TupleTypeReplacer : public GenPoly::DeclMutator {
+                  public:
+                        typedef GenPoly::DeclMutator Parent;
+                        using Parent::mutate;
+                        virtual Type * mutate( TupleType * tupleType ) override;
+                        virtual CompoundStmt * mutate( CompoundStmt * stmt ) override {
+                                typeMap.beginScope();
+                                stmt = Parent::mutate( stmt );
+                                typeMap.endScope();
+                                return stmt;
+                        }
                   private:
 …
                 mutateAll( translationUnit, assnExpander );
                 PassVisitor<TupleTypeReplacer> replacer;
                 mutateAll( translationUnit, replacer );
+                TupleTypeReplacer replacer;
+                replacer.mutateDeclarationList( translationUnit );
                 PassVisitor<TupleIndexExpander> idxExpander;
 …
+        }
+        Type * TupleTypeReplacer::postmutate( TupleType * tupleType ) {
+        Type * TupleTypeReplacer::mutate( TupleType * tupleType ) {
+                tupleType = safe_dynamic_cast< TupleType * > ( Parent::mutate( tupleType ) );
                 unsigned tupleSize = tupleType->size();
                 if ( ! typeMap.count( tupleSize ) ) {
 …
                         decl->set_body( true );
                         for ( size_t i = 0; i < tupleSize; ++i ) {
                                 TypeDecl * tyParam = new TypeDecl( toString( "tuple_param_", tupleSize, "_", i ), Type::StorageClasses(), nullptr, TypeDecl::Any );
+                                TypeDecl * tyParam = new TypeDecl( toString( "tuple_param_", i ), Type::StorageClasses(), nullptr, TypeDecl::Any );
                                 decl->get_members().push_back( new ObjectDecl( toString("field_", i ), Type::StorageClasses(), LinkageSpec::C, nullptr, new TypeInstType( Type::Qualifiers(), tyParam->get_name(), tyParam ), nullptr ) );
                                 decl->get_parameters().push_back( tyParam );
 …
+                        }
                         typeMap[tupleSize] = decl;
                         declsToAddBefore.push_back( decl );
+                        addDeclaration( decl );
+                }
                 Type::Qualifiers qualifiers = tupleType->get_qualifiers();
 …
                 StructDecl * decl = typeMap[tupleSize];
                 StructInstType * newType = new StructInstType( qualifiers, decl );
+                for ( auto p : group_iterate( tupleType->get_types(), decl->get_parameters() ) ) {
+                        Type * t = std::get<0>(p);
+                        TypeDecl * td = std::get<1>(p);
+                for ( Type * t : *tupleType ) {
                         newType->get_parameters().push_back( new TypeExpr( t->clone() ) );
-                        if ( env ) {
-                                // add bindings to the type environment.
-                                // xxx - This may not be sufficient, it may be necessary to rename type variables on StructInstType?
-                                env->add( td->get_name(), t->clone() );
+                        }
+                }
                 delete tupleType;

src/Tuples/Tuples.h

-              r0720e049
+              r3d4b23fa
 // Author           : Rodolfo G. Esteves
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 09:55:00 2017
 // Update Count     : 16
+// Last Modified By : Rob Schluntz
+// Last Modified On : Wed Nov 9 13:17:58 2016
+// Update Count     : 15
 //
+#pragma once
+#ifndef _TUPLES_H_
+#define _TUPLES_H_
 #include <string>
 …
 } // namespace Tuples
+#endif // _TUPLE_ASSIGNMENT_H_
 // Local Variables: //
 // tab-width: 4 //

src/benchmark/create_pthrd.c

r0720e049	r3d4b23fa
14	14	n = atoi(argv[1]);
15	15	}
16		printf("~~create %lu pthreads ...~~ ", n);
	16	printf("%lu\n", n);
17	17
18	18	for (size_t i = 0; i < n; i++) {
19	19	pthread_t thread;
20	20	if (pthread_create(&thread, NULL, foo, NULL) < 0) {
21		~~perror( "failure" );~~
22	21	return 1;
23	22	}
24	23
25	24	if (pthread_join( thread, NULL) < 0) {
26		~~perror( "failure" );~~
27	25	return 1;
28	26	}
29	27	}
30		printf("finish\n");
	28	pthread_exit(NULL);
	29	return 0;
31	30	}

src/libcfa/Makefile.am

-              r0720e049
+              r3d4b23fa
 ## Created On       : Sun May 31 08:54:01 2015
 ## Last Modified By : Andrew Beach
 ## Last Modified On : Wed Jul 26 14:15:00 2017
 ## Update Count     : 221
+## Last Modified On : Wed Jun 28 15:36:00 2017
+## Update Count     : 215
 ###############################################################################
 …
 AM_CCASFLAGS = @CFA_FLAGS@
+#CFLAGS for most libcfa src
+#use -no-include-stdhdr to prevent rebuild cycles
+#The built sources must not depend on the installed headers
+CFLAGS = -quiet -no-include-stdhdr -I${abs_top_srcdir}/src/libcfa/stdhdr -XCFA -t -B${abs_top_srcdir}/src/driver ${EXTRA_FLAGS}
+CFLAGS = -quiet -no-include-stdhdr -XCFA -t -B${abs_top_srcdir}/src/driver ${EXTRA_FLAGS}
 CC = ${abs_top_srcdir}/src/driver/cfa
 headers = fstream iostream iterator limits rational stdlib \
+headers = assert fstream iostream iterator limits math rational stdlib \
           containers/maybe containers/pair containers/result containers/vector
 …
 libobjs = ${headers:=.o}
+libsrc = libcfa-prelude.c interpose.c libhdr/libdebug.c ${headers:=.c} \
+         assert.c exception.c virtual.c
+libsrc = libcfa-prelude.c interpose.c libhdr/libdebug.c ${headers:=.c} exception.c
 # not all platforms support concurrency, add option do disable it
 …
         ${AM_V_CC}@BACKEND_CC@ -DHAVE_CONFIG_H -I. -I../.. -O2 ${EXTRA_FLAGS} -c -o $@ $<
-libcfa_a-virtual.o : virtual.c
-        ${AM_V_CC}@BACKEND_CC@ -DHAVE_CONFIG_H -I. -I../.. -O2 ${EXTRA_FLAGS} -c -o $@ $<
 concurrency/libcfa_d_a-invoke.o : concurrency/invoke.c
         ${AM_V_CC}@BACKEND_CC@ -DHAVE_CONFIG_H -I. -I../.. -D__CFA_DEBUG__ -O0 ${EXTRA_FLAGS} -c -o $@ $<
 libcfa_d_a-exception.o : exception.c
-        ${AM_V_CC}@BACKEND_CC@ -DHAVE_CONFIG_H -I. -I../.. -D__CFA_DEBUG__ -O0 ${EXTRA_FLAGS} -c -o $@ $<
-libcfa_d_a-virtual.o : virtual.c
         ${AM_V_CC}@BACKEND_CC@ -DHAVE_CONFIG_H -I. -I../.. -D__CFA_DEBUG__ -O0 ${EXTRA_FLAGS} -c -o $@ $<
 …
 cfa_includedir = $(CFA_INCDIR)
 nobase_cfa_include_HEADERS = ${headers} ${stdhdr} math gmp concurrency/invoke.h
+nobase_cfa_include_HEADERS = ${headers} ${stdhdr} gmp concurrency/invoke.h
 CLEANFILES = libcfa-prelude.c

src/libcfa/Makefile.in

-              r0720e049
+              r3d4b23fa
 libcfa_d_a_LIBADD =
 am__libcfa_d_a_SOURCES_DIST = libcfa-prelude.c interpose.c \
         libhdr/libdebug.c fstream.c iostream.c iterator.c limits.c \
         rational.c stdlib.c containers/maybe.c containers/pair.c \
         containers/result.c containers/vector.c \
+        libhdr/libdebug.c assert.c fstream.c iostream.c iterator.c \
+        limits.c math.c rational.c stdlib.c containers/maybe.c \
+        containers/pair.c containers/result.c containers/vector.c \
         concurrency/coroutine.c concurrency/thread.c \
+        concurrency/kernel.c concurrency/monitor.c assert.c \
+        exception.c virtual.c concurrency/CtxSwitch-@MACHINE_TYPE@.S \
+        concurrency/alarm.c concurrency/invoke.c \
+        concurrency/preemption.c
+        concurrency/kernel.c concurrency/monitor.c exception.c \
+        concurrency/CtxSwitch-@MACHINE_TYPE@.S concurrency/alarm.c \
+        concurrency/invoke.c concurrency/preemption.c
 am__dirstamp = $(am__leading_dot)dirstamp
 @BUILD_CONCURRENCY_TRUE@am__objects_1 = concurrency/libcfa_d_a-coroutine.$(OBJEXT) \
 …
 @BUILD_CONCURRENCY_TRUE@        concurrency/libcfa_d_a-kernel.$(OBJEXT) \
 @BUILD_CONCURRENCY_TRUE@        concurrency/libcfa_d_a-monitor.$(OBJEXT)
+am__objects_2 = libcfa_d_a-fstream.$(OBJEXT) \
+        libcfa_d_a-iostream.$(OBJEXT) libcfa_d_a-iterator.$(OBJEXT) \
+        libcfa_d_a-limits.$(OBJEXT) libcfa_d_a-rational.$(OBJEXT) \
+am__objects_2 = libcfa_d_a-assert.$(OBJEXT) \
+        libcfa_d_a-fstream.$(OBJEXT) libcfa_d_a-iostream.$(OBJEXT) \
+        libcfa_d_a-iterator.$(OBJEXT) libcfa_d_a-limits.$(OBJEXT) \
+        libcfa_d_a-math.$(OBJEXT) libcfa_d_a-rational.$(OBJEXT) \
         libcfa_d_a-stdlib.$(OBJEXT) \
         containers/libcfa_d_a-maybe.$(OBJEXT) \
 …
         libcfa_d_a-interpose.$(OBJEXT) \
         libhdr/libcfa_d_a-libdebug.$(OBJEXT) $(am__objects_2) \
+        libcfa_d_a-assert.$(OBJEXT) libcfa_d_a-exception.$(OBJEXT) \
+        libcfa_d_a-virtual.$(OBJEXT) $(am__objects_3)
+        libcfa_d_a-exception.$(OBJEXT) $(am__objects_3)
 am_libcfa_d_a_OBJECTS = $(am__objects_4)
 libcfa_d_a_OBJECTS = $(am_libcfa_d_a_OBJECTS)
 …
 libcfa_a_LIBADD =
 am__libcfa_a_SOURCES_DIST = libcfa-prelude.c interpose.c \
         libhdr/libdebug.c fstream.c iostream.c iterator.c limits.c \
         rational.c stdlib.c containers/maybe.c containers/pair.c \
         containers/result.c containers/vector.c \
+        libhdr/libdebug.c assert.c fstream.c iostream.c iterator.c \
+        limits.c math.c rational.c stdlib.c containers/maybe.c \
+        containers/pair.c containers/result.c containers/vector.c \
         concurrency/coroutine.c concurrency/thread.c \
+        concurrency/kernel.c concurrency/monitor.c assert.c \
+        exception.c virtual.c concurrency/CtxSwitch-@MACHINE_TYPE@.S \
+        concurrency/alarm.c concurrency/invoke.c \
+        concurrency/preemption.c
+        concurrency/kernel.c concurrency/monitor.c exception.c \
+        concurrency/CtxSwitch-@MACHINE_TYPE@.S concurrency/alarm.c \
+        concurrency/invoke.c concurrency/preemption.c
 @BUILD_CONCURRENCY_TRUE@am__objects_5 = concurrency/libcfa_a-coroutine.$(OBJEXT) \
 @BUILD_CONCURRENCY_TRUE@        concurrency/libcfa_a-thread.$(OBJEXT) \
 @BUILD_CONCURRENCY_TRUE@        concurrency/libcfa_a-kernel.$(OBJEXT) \
 @BUILD_CONCURRENCY_TRUE@        concurrency/libcfa_a-monitor.$(OBJEXT)
+am__objects_6 = libcfa_a-fstream.$(OBJEXT) libcfa_a-iostream.$(OBJEXT) \
+        libcfa_a-iterator.$(OBJEXT) libcfa_a-limits.$(OBJEXT) \
+am__objects_6 = libcfa_a-assert.$(OBJEXT) libcfa_a-fstream.$(OBJEXT) \
+        libcfa_a-iostream.$(OBJEXT) libcfa_a-iterator.$(OBJEXT) \
+        libcfa_a-limits.$(OBJEXT) libcfa_a-math.$(OBJEXT) \
         libcfa_a-rational.$(OBJEXT) libcfa_a-stdlib.$(OBJEXT) \
         containers/libcfa_a-maybe.$(OBJEXT) \
 …
         libcfa_a-interpose.$(OBJEXT) \
         libhdr/libcfa_a-libdebug.$(OBJEXT) $(am__objects_6) \
+        libcfa_a-assert.$(OBJEXT) libcfa_a-exception.$(OBJEXT) \
+        libcfa_a-virtual.$(OBJEXT) $(am__objects_7)
+        libcfa_a-exception.$(OBJEXT) $(am__objects_7)
 am_libcfa_a_OBJECTS = $(am__objects_8)
 libcfa_a_OBJECTS = $(am_libcfa_a_OBJECTS)
 …
     *) (install-info --version) >/dev/null 2>&1;; \
   esac
 am__nobase_cfa_include_HEADERS_DIST = fstream iostream iterator limits \
         rational stdlib containers/maybe containers/pair \
+am__nobase_cfa_include_HEADERS_DIST = assert fstream iostream iterator \
+        limits math rational stdlib containers/maybe containers/pair \
         containers/result containers/vector concurrency/coroutine \
         concurrency/thread concurrency/kernel concurrency/monitor \
         ${shell echo stdhdr/*} math gmp concurrency/invoke.h
+        ${shell echo stdhdr/*} gmp concurrency/invoke.h
 HEADERS = $(nobase_cfa_include_HEADERS)
 am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) $(LISP)
 …
 CFA_NAME = @CFA_NAME@
 CFA_PREFIX = @CFA_PREFIX@
+#CFLAGS for most libcfa src
+#use -no-include-stdhdr to prevent rebuild cycles
+#The built sources must not depend on the installed headers
+CFLAGS = -quiet -no-include-stdhdr -I${abs_top_srcdir}/src/libcfa/stdhdr -XCFA -t -B${abs_top_srcdir}/src/driver ${EXTRA_FLAGS}
+CFLAGS = -quiet -no-include-stdhdr -XCFA -t -B${abs_top_srcdir}/src/driver ${EXTRA_FLAGS}
 CPP = @CPP@
 CPPFLAGS = @CPPFLAGS@
 …
 EXTRA_FLAGS = -g -Wall -Werror -Wno-unused-function -I${abs_top_srcdir}/src/libcfa/libhdr -imacros libcfa-prelude.c @CFA_FLAGS@
 AM_CCASFLAGS = @CFA_FLAGS@
 headers = fstream iostream iterator limits rational stdlib \
+headers = assert fstream iostream iterator limits math rational stdlib \
         containers/maybe containers/pair containers/result \
         containers/vector $(am__append_3)
 libobjs = ${headers:=.o}
 libsrc = libcfa-prelude.c interpose.c libhdr/libdebug.c ${headers:=.c} \
         assert.c exception.c virtual.c $(am__append_4)
+        exception.c $(am__append_4)
 libcfa_a_SOURCES = ${libsrc}
 libcfa_a_CFLAGS = -nodebug -O2
 …
 stdhdr = ${shell echo stdhdr/*}
 cfa_includedir = $(CFA_INCDIR)
 nobase_cfa_include_HEADERS = ${headers} ${stdhdr} math gmp concurrency/invoke.h
+nobase_cfa_include_HEADERS = ${headers} ${stdhdr} gmp concurrency/invoke.h
 CLEANFILES = libcfa-prelude.c
 all: all-am
 …
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libcfa_a-libcfa-prelude.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libcfa_a-limits.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libcfa_a-math.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libcfa_a-rational.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libcfa_a-stdlib.Po@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libcfa_a-virtual.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libcfa_d_a-assert.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libcfa_d_a-exception.Po@am__quote@
 …
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libcfa_d_a-libcfa-prelude.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libcfa_d_a-limits.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libcfa_d_a-math.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libcfa_d_a-rational.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libcfa_d_a-stdlib.Po@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libcfa_d_a-virtual.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@concurrency/$(DEPDIR)/CtxSwitch-@MACHINE_TYPE@.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@concurrency/$(DEPDIR)/libcfa_a-alarm.Po@am__quote@
 …
 @am__fastdepCC_FALSE@   $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -c -o libhdr/libcfa_d_a-libdebug.obj `if test -f 'libhdr/libdebug.c'; then $(CYGPATH_W) 'libhdr/libdebug.c'; else $(CYGPATH_W) '$(srcdir)/libhdr/libdebug.c'; fi`
+libcfa_d_a-assert.o: assert.c
+@am__fastdepCC_TRUE@    $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -MT libcfa_d_a-assert.o -MD -MP -MF $(DEPDIR)/libcfa_d_a-assert.Tpo -c -o libcfa_d_a-assert.o `test -f 'assert.c' || echo '$(srcdir)/'`assert.c
+@am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) $(DEPDIR)/libcfa_d_a-assert.Tpo $(DEPDIR)/libcfa_d_a-assert.Po
+@AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='assert.c' object='libcfa_d_a-assert.o' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@       DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@   $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -c -o libcfa_d_a-assert.o `test -f 'assert.c' || echo '$(srcdir)/'`assert.c
+libcfa_d_a-assert.obj: assert.c
+@am__fastdepCC_TRUE@    $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -MT libcfa_d_a-assert.obj -MD -MP -MF $(DEPDIR)/libcfa_d_a-assert.Tpo -c -o libcfa_d_a-assert.obj `if test -f 'assert.c'; then $(CYGPATH_W) 'assert.c'; else $(CYGPATH_W) '$(srcdir)/assert.c'; fi`
+@am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) $(DEPDIR)/libcfa_d_a-assert.Tpo $(DEPDIR)/libcfa_d_a-assert.Po
+@AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='assert.c' object='libcfa_d_a-assert.obj' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@       DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@   $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -c -o libcfa_d_a-assert.obj `if test -f 'assert.c'; then $(CYGPATH_W) 'assert.c'; else $(CYGPATH_W) '$(srcdir)/assert.c'; fi`
 libcfa_d_a-fstream.o: fstream.c
 @am__fastdepCC_TRUE@    $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -MT libcfa_d_a-fstream.o -MD -MP -MF $(DEPDIR)/libcfa_d_a-fstream.Tpo -c -o libcfa_d_a-fstream.o `test -f 'fstream.c' || echo '$(srcdir)/'`fstream.c
 …
 @am__fastdepCC_FALSE@   $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -c -o libcfa_d_a-limits.obj `if test -f 'limits.c'; then $(CYGPATH_W) 'limits.c'; else $(CYGPATH_W) '$(srcdir)/limits.c'; fi`
+libcfa_d_a-math.o: math.c
+@am__fastdepCC_TRUE@    $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -MT libcfa_d_a-math.o -MD -MP -MF $(DEPDIR)/libcfa_d_a-math.Tpo -c -o libcfa_d_a-math.o `test -f 'math.c' || echo '$(srcdir)/'`math.c
+@am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) $(DEPDIR)/libcfa_d_a-math.Tpo $(DEPDIR)/libcfa_d_a-math.Po
+@AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='math.c' object='libcfa_d_a-math.o' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@       DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@   $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -c -o libcfa_d_a-math.o `test -f 'math.c' || echo '$(srcdir)/'`math.c
+libcfa_d_a-math.obj: math.c
+@am__fastdepCC_TRUE@    $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -MT libcfa_d_a-math.obj -MD -MP -MF $(DEPDIR)/libcfa_d_a-math.Tpo -c -o libcfa_d_a-math.obj `if test -f 'math.c'; then $(CYGPATH_W) 'math.c'; else $(CYGPATH_W) '$(srcdir)/math.c'; fi`
+@am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) $(DEPDIR)/libcfa_d_a-math.Tpo $(DEPDIR)/libcfa_d_a-math.Po
+@AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='math.c' object='libcfa_d_a-math.obj' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@       DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@   $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -c -o libcfa_d_a-math.obj `if test -f 'math.c'; then $(CYGPATH_W) 'math.c'; else $(CYGPATH_W) '$(srcdir)/math.c'; fi`
 libcfa_d_a-rational.o: rational.c
 @am__fastdepCC_TRUE@    $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -MT libcfa_d_a-rational.o -MD -MP -MF $(DEPDIR)/libcfa_d_a-rational.Tpo -c -o libcfa_d_a-rational.o `test -f 'rational.c' || echo '$(srcdir)/'`rational.c
 …
 @am__fastdepCC_FALSE@   $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -c -o concurrency/libcfa_d_a-monitor.obj `if test -f 'concurrency/monitor.c'; then $(CYGPATH_W) 'concurrency/monitor.c'; else $(CYGPATH_W) '$(srcdir)/concurrency/monitor.c'; fi`
-libcfa_d_a-assert.o: assert.c
-@am__fastdepCC_TRUE@    $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -MT libcfa_d_a-assert.o -MD -MP -MF $(DEPDIR)/libcfa_d_a-assert.Tpo -c -o libcfa_d_a-assert.o `test -f 'assert.c' || echo '$(srcdir)/'`assert.c
-@am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) $(DEPDIR)/libcfa_d_a-assert.Tpo $(DEPDIR)/libcfa_d_a-assert.Po
-@AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='assert.c' object='libcfa_d_a-assert.o' libtool=no @AMDEPBACKSLASH@
-@AMDEP_TRUE@@am__fastdepCC_FALSE@       DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
-@am__fastdepCC_FALSE@   $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -c -o libcfa_d_a-assert.o `test -f 'assert.c' || echo '$(srcdir)/'`assert.c
-libcfa_d_a-assert.obj: assert.c
-@am__fastdepCC_TRUE@    $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -MT libcfa_d_a-assert.obj -MD -MP -MF $(DEPDIR)/libcfa_d_a-assert.Tpo -c -o libcfa_d_a-assert.obj `if test -f 'assert.c'; then $(CYGPATH_W) 'assert.c'; else $(CYGPATH_W) '$(srcdir)/assert.c'; fi`
-@am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) $(DEPDIR)/libcfa_d_a-assert.Tpo $(DEPDIR)/libcfa_d_a-assert.Po
-@AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='assert.c' object='libcfa_d_a-assert.obj' libtool=no @AMDEPBACKSLASH@
-@AMDEP_TRUE@@am__fastdepCC_FALSE@       DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
-@am__fastdepCC_FALSE@   $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -c -o libcfa_d_a-assert.obj `if test -f 'assert.c'; then $(CYGPATH_W) 'assert.c'; else $(CYGPATH_W) '$(srcdir)/assert.c'; fi`
 libcfa_d_a-exception.obj: exception.c
 @am__fastdepCC_TRUE@    $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -MT libcfa_d_a-exception.obj -MD -MP -MF $(DEPDIR)/libcfa_d_a-exception.Tpo -c -o libcfa_d_a-exception.obj `if test -f 'exception.c'; then $(CYGPATH_W) 'exception.c'; else $(CYGPATH_W) '$(srcdir)/exception.c'; fi`
 …
 @am__fastdepCC_FALSE@   $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -c -o libcfa_d_a-exception.obj `if test -f 'exception.c'; then $(CYGPATH_W) 'exception.c'; else $(CYGPATH_W) '$(srcdir)/exception.c'; fi`
-libcfa_d_a-virtual.obj: virtual.c
-@am__fastdepCC_TRUE@    $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -MT libcfa_d_a-virtual.obj -MD -MP -MF $(DEPDIR)/libcfa_d_a-virtual.Tpo -c -o libcfa_d_a-virtual.obj `if test -f 'virtual.c'; then $(CYGPATH_W) 'virtual.c'; else $(CYGPATH_W) '$(srcdir)/virtual.c'; fi`
-@am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) $(DEPDIR)/libcfa_d_a-virtual.Tpo $(DEPDIR)/libcfa_d_a-virtual.Po
-@AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='virtual.c' object='libcfa_d_a-virtual.obj' libtool=no @AMDEPBACKSLASH@
-@AMDEP_TRUE@@am__fastdepCC_FALSE@       DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
-@am__fastdepCC_FALSE@   $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -c -o libcfa_d_a-virtual.obj `if test -f 'virtual.c'; then $(CYGPATH_W) 'virtual.c'; else $(CYGPATH_W) '$(srcdir)/virtual.c'; fi`
 concurrency/libcfa_d_a-alarm.o: concurrency/alarm.c
 @am__fastdepCC_TRUE@    $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -MT concurrency/libcfa_d_a-alarm.o -MD -MP -MF concurrency/$(DEPDIR)/libcfa_d_a-alarm.Tpo -c -o concurrency/libcfa_d_a-alarm.o `test -f 'concurrency/alarm.c' || echo '$(srcdir)/'`concurrency/alarm.c
 …
 @am__fastdepCC_FALSE@   $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -c -o libhdr/libcfa_a-libdebug.obj `if test -f 'libhdr/libdebug.c'; then $(CYGPATH_W) 'libhdr/libdebug.c'; else $(CYGPATH_W) '$(srcdir)/libhdr/libdebug.c'; fi`
+libcfa_a-assert.o: assert.c
+@am__fastdepCC_TRUE@    $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -MT libcfa_a-assert.o -MD -MP -MF $(DEPDIR)/libcfa_a-assert.Tpo -c -o libcfa_a-assert.o `test -f 'assert.c' || echo '$(srcdir)/'`assert.c
+@am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) $(DEPDIR)/libcfa_a-assert.Tpo $(DEPDIR)/libcfa_a-assert.Po
+@AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='assert.c' object='libcfa_a-assert.o' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@       DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@   $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -c -o libcfa_a-assert.o `test -f 'assert.c' || echo '$(srcdir)/'`assert.c
+libcfa_a-assert.obj: assert.c
+@am__fastdepCC_TRUE@    $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -MT libcfa_a-assert.obj -MD -MP -MF $(DEPDIR)/libcfa_a-assert.Tpo -c -o libcfa_a-assert.obj `if test -f 'assert.c'; then $(CYGPATH_W) 'assert.c'; else $(CYGPATH_W) '$(srcdir)/assert.c'; fi`
+@am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) $(DEPDIR)/libcfa_a-assert.Tpo $(DEPDIR)/libcfa_a-assert.Po
+@AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='assert.c' object='libcfa_a-assert.obj' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@       DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@   $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -c -o libcfa_a-assert.obj `if test -f 'assert.c'; then $(CYGPATH_W) 'assert.c'; else $(CYGPATH_W) '$(srcdir)/assert.c'; fi`
 libcfa_a-fstream.o: fstream.c
 @am__fastdepCC_TRUE@    $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -MT libcfa_a-fstream.o -MD -MP -MF $(DEPDIR)/libcfa_a-fstream.Tpo -c -o libcfa_a-fstream.o `test -f 'fstream.c' || echo '$(srcdir)/'`fstream.c
 …
 @am__fastdepCC_FALSE@   $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -c -o libcfa_a-limits.obj `if test -f 'limits.c'; then $(CYGPATH_W) 'limits.c'; else $(CYGPATH_W) '$(srcdir)/limits.c'; fi`
+libcfa_a-math.o: math.c
+@am__fastdepCC_TRUE@    $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -MT libcfa_a-math.o -MD -MP -MF $(DEPDIR)/libcfa_a-math.Tpo -c -o libcfa_a-math.o `test -f 'math.c' || echo '$(srcdir)/'`math.c
+@am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) $(DEPDIR)/libcfa_a-math.Tpo $(DEPDIR)/libcfa_a-math.Po
+@AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='math.c' object='libcfa_a-math.o' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@       DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@   $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -c -o libcfa_a-math.o `test -f 'math.c' || echo '$(srcdir)/'`math.c
+libcfa_a-math.obj: math.c
+@am__fastdepCC_TRUE@    $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -MT libcfa_a-math.obj -MD -MP -MF $(DEPDIR)/libcfa_a-math.Tpo -c -o libcfa_a-math.obj `if test -f 'math.c'; then $(CYGPATH_W) 'math.c'; else $(CYGPATH_W) '$(srcdir)/math.c'; fi`
+@am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) $(DEPDIR)/libcfa_a-math.Tpo $(DEPDIR)/libcfa_a-math.Po
+@AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='math.c' object='libcfa_a-math.obj' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@       DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@   $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -c -o libcfa_a-math.obj `if test -f 'math.c'; then $(CYGPATH_W) 'math.c'; else $(CYGPATH_W) '$(srcdir)/math.c'; fi`
 libcfa_a-rational.o: rational.c
 @am__fastdepCC_TRUE@    $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -MT libcfa_a-rational.o -MD -MP -MF $(DEPDIR)/libcfa_a-rational.Tpo -c -o libcfa_a-rational.o `test -f 'rational.c' || echo '$(srcdir)/'`rational.c
 …
 @am__fastdepCC_FALSE@   $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -c -o concurrency/libcfa_a-monitor.obj `if test -f 'concurrency/monitor.c'; then $(CYGPATH_W) 'concurrency/monitor.c'; else $(CYGPATH_W) '$(srcdir)/concurrency/monitor.c'; fi`
-libcfa_a-assert.o: assert.c
-@am__fastdepCC_TRUE@    $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -MT libcfa_a-assert.o -MD -MP -MF $(DEPDIR)/libcfa_a-assert.Tpo -c -o libcfa_a-assert.o `test -f 'assert.c' || echo '$(srcdir)/'`assert.c
-@am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) $(DEPDIR)/libcfa_a-assert.Tpo $(DEPDIR)/libcfa_a-assert.Po
-@AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='assert.c' object='libcfa_a-assert.o' libtool=no @AMDEPBACKSLASH@
-@AMDEP_TRUE@@am__fastdepCC_FALSE@       DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
-@am__fastdepCC_FALSE@   $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -c -o libcfa_a-assert.o `test -f 'assert.c' || echo '$(srcdir)/'`assert.c
-libcfa_a-assert.obj: assert.c
-@am__fastdepCC_TRUE@    $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -MT libcfa_a-assert.obj -MD -MP -MF $(DEPDIR)/libcfa_a-assert.Tpo -c -o libcfa_a-assert.obj `if test -f 'assert.c'; then $(CYGPATH_W) 'assert.c'; else $(CYGPATH_W) '$(srcdir)/assert.c'; fi`
-@am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) $(DEPDIR)/libcfa_a-assert.Tpo $(DEPDIR)/libcfa_a-assert.Po
-@AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='assert.c' object='libcfa_a-assert.obj' libtool=no @AMDEPBACKSLASH@
-@AMDEP_TRUE@@am__fastdepCC_FALSE@       DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
-@am__fastdepCC_FALSE@   $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -c -o libcfa_a-assert.obj `if test -f 'assert.c'; then $(CYGPATH_W) 'assert.c'; else $(CYGPATH_W) '$(srcdir)/assert.c'; fi`
 libcfa_a-exception.obj: exception.c
 @am__fastdepCC_TRUE@    $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -MT libcfa_a-exception.obj -MD -MP -MF $(DEPDIR)/libcfa_a-exception.Tpo -c -o libcfa_a-exception.obj `if test -f 'exception.c'; then $(CYGPATH_W) 'exception.c'; else $(CYGPATH_W) '$(srcdir)/exception.c'; fi`
 …
 @AMDEP_TRUE@@am__fastdepCC_FALSE@       DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
 @am__fastdepCC_FALSE@   $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -c -o libcfa_a-exception.obj `if test -f 'exception.c'; then $(CYGPATH_W) 'exception.c'; else $(CYGPATH_W) '$(srcdir)/exception.c'; fi`
-libcfa_a-virtual.obj: virtual.c
-@am__fastdepCC_TRUE@    $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -MT libcfa_a-virtual.obj -MD -MP -MF $(DEPDIR)/libcfa_a-virtual.Tpo -c -o libcfa_a-virtual.obj `if test -f 'virtual.c'; then $(CYGPATH_W) 'virtual.c'; else $(CYGPATH_W) '$(srcdir)/virtual.c'; fi`
-@am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) $(DEPDIR)/libcfa_a-virtual.Tpo $(DEPDIR)/libcfa_a-virtual.Po
-@AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='virtual.c' object='libcfa_a-virtual.obj' libtool=no @AMDEPBACKSLASH@
-@AMDEP_TRUE@@am__fastdepCC_FALSE@       DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
-@am__fastdepCC_FALSE@   $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -c -o libcfa_a-virtual.obj `if test -f 'virtual.c'; then $(CYGPATH_W) 'virtual.c'; else $(CYGPATH_W) '$(srcdir)/virtual.c'; fi`
 concurrency/libcfa_a-alarm.o: concurrency/alarm.c
 …
         ${AM_V_CC}@BACKEND_CC@ -DHAVE_CONFIG_H -I. -I../.. -O2 ${EXTRA_FLAGS} -c -o $@ $<
-libcfa_a-virtual.o : virtual.c
-        ${AM_V_CC}@BACKEND_CC@ -DHAVE_CONFIG_H -I. -I../.. -O2 ${EXTRA_FLAGS} -c -o $@ $<
 concurrency/libcfa_d_a-invoke.o : concurrency/invoke.c
         ${AM_V_CC}@BACKEND_CC@ -DHAVE_CONFIG_H -I. -I../.. -D__CFA_DEBUG__ -O0 ${EXTRA_FLAGS} -c -o $@ $<
 libcfa_d_a-exception.o : exception.c
-        ${AM_V_CC}@BACKEND_CC@ -DHAVE_CONFIG_H -I. -I../.. -D__CFA_DEBUG__ -O0 ${EXTRA_FLAGS} -c -o $@ $<
-libcfa_d_a-virtual.o : virtual.c
         ${AM_V_CC}@BACKEND_CC@ -DHAVE_CONFIG_H -I. -I../.. -D__CFA_DEBUG__ -O0 ${EXTRA_FLAGS} -c -o $@ $<

src/libcfa/assert.c

-              r0720e049
+              r3d4b23fa
 // Author           : Thierry Delisle
 // Created On       : Mon Nov 28 12:27:26 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Jul 20 15:10:26 2017
 // Update Count     : 2
+// Last Modified By : Thierry Delisle
+// Last Modified On : Mon Nov 28 12:27:26 2016
+// Update Count     : 0
 //
 #include <assert.h>
 #include <stdarg.h>                                                             // varargs
+#include <stdio.h>                                                              // fprintf
+#include "assert"
+#include "stdlib"                                                                               // abort
 #include "libhdr/libdebug.h"
 extern "C" {
+        #include <stdarg.h>                                                             // varargs
+        #include <stdio.h>                                                              // fprintf
         extern const char * __progname;                                         // global name of running executable (argv[0])
 …
                 abort();
+        }
+}

src/libcfa/concurrency/CtxSwitch-i386.S

-              r0720e049
+              r3d4b23fa
+//                               -*- Mode: Asm -*-
 //
 // Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo
 …
 // Author           : Thierry Delisle
 // Created On       : Tue Dec 6 12:27:26 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Jul 21 22:29:25 2017
 // Update Count     : 1
+// Last Modified By : Thierry Delisle
+// Last Modified On : Tue Dec 6 12:27:26 2016
+// Update Count     : 0
 //
 // This  library is free  software; you  can redistribute  it and/or  modify it
 …
 // Local Variables: //
+// mode: c //
+// tab-width: 4 //
+// compile-command: "make install" //
 // End: //

src/libcfa/concurrency/CtxSwitch-x86_64.S

-              r0720e049
+              r3d4b23fa
+//                               -*- Mode: Asm -*-
 //
 // Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo
 …
 // Author           : Thierry Delisle
 // Created On       : Mon Nov 28 12:27:26 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Jul 21 22:28:11 2017
 // Update Count     : 1
+// Last Modified By : Thierry Delisle
+// Last Modified On : Mon Nov 28 12:27:26 2016
+// Update Count     : 0
 //
 // This  library is free  software; you  can redistribute  it and/or  modify it

src/libcfa/concurrency/alarm.c

-              r0720e049
+              r3d4b23fa
+//                              -*- Mode: CFA -*-
 //
 // Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo
 …
 // Author           : Thierry Delisle
 // Created On       : Fri Jun 2 11:31:25 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Jul 21 22:35:18 2017
 // Update Count     : 1
+// Last Modified By : Thierry Delisle
+// Last Modified On : --
+// Update Count     : 0
 //
 …
 //=============================================================================================
-// time type
-//=============================================================================================
-#define one_second         1_000_000_000ul
-#define one_milisecond         1_000_000ul
-#define one_microsecond            1_000ul
-#define one_nanosecond                 1ul
-__cfa_time_t zero_time = { 0 };
-void ?{}( __cfa_time_t * this ) { this->val = 0; }
-void ?{}( __cfa_time_t * this, zero_t zero ) { this->val = 0; }
-void ?{}( itimerval * this, __cfa_time_t * alarm ) {
-        this->it_value.tv_sec = alarm->val / one_second;                        // seconds
-        this->it_value.tv_usec = max( (alarm->val % one_second) / one_microsecond, 1000 ); // microseconds
-        this->it_interval.tv_sec = 0;
-        this->it_interval.tv_usec = 0;
+}
-void ?{}( __cfa_time_t * this, timespec * curr ) {
-        uint64_t secs  = curr->tv_sec;
-        uint64_t nsecs = curr->tv_nsec;
-        this->val = (secs * one_second) + nsecs;
+}
-__cfa_time_t ?=?( __cfa_time_t * this, zero_t rhs ) {
-        this->val = 0;
-        return *this;
+}
-__cfa_time_t from_s ( uint64_t val ) { __cfa_time_t ret; ret.val = val * 1_000_000_000ul; return ret; }
-__cfa_time_t from_ms( uint64_t val ) { __cfa_time_t ret; ret.val = val *     1_000_000ul; return ret; }
-__cfa_time_t from_us( uint64_t val ) { __cfa_time_t ret; ret.val = val *         1_000ul; return ret; }
-__cfa_time_t from_ns( uint64_t val ) { __cfa_time_t ret; ret.val = val *             1ul; return ret; }
-//=============================================================================================
 // Clock logic
 //=============================================================================================
 …
         timespec curr;
         clock_gettime( CLOCK_REALTIME, &curr );
+        return (__cfa_time_t){ &curr };
+        __cfa_time_t curr_time = ((__cfa_time_t)curr.tv_sec * TIMEGRAN) + curr.tv_nsec;
+        // LIB_DEBUG_PRINT_BUFFER_DECL( STDERR_FILENO, "Kernel : current time is %lu\n", curr_time );
+        return curr_time;
+}
 void __kernel_set_timer( __cfa_time_t alarm ) {
+        itimerval val = { &alarm };
+        LIB_DEBUG_PRINT_BUFFER_DECL( STDERR_FILENO, "Kernel : set timer to %lu\n", (__cfa_time_t)alarm );
+        itimerval val;
+        val.it_value.tv_sec = alarm / TIMEGRAN;                 // seconds
+        val.it_value.tv_usec = (alarm % TIMEGRAN) / ( TIMEGRAN / 1_000_000L ); // microseconds
+        val.it_interval.tv_sec = 0;
+        val.it_interval.tv_usec = 0;
         setitimer( ITIMER_REAL, &val, NULL );
+}
 …
 //=============================================================================================
 void ?{}( alarm_node_t * this, thread_desc * thrd, __cfa_time_t alarm = zero_time, __cfa_time_t period = zero_time ) {
+void ?{}( alarm_node_t * this, thread_desc * thrd, __cfa_time_t alarm = 0, __cfa_time_t period = 0 ) {
         this->thrd = thrd;
         this->alarm = alarm;
 …
+}
 void ?{}( alarm_node_t * this, processor   * proc, __cfa_time_t alarm = zero_time, __cfa_time_t period = zero_time ) {
+void ?{}( alarm_node_t * this, processor   * proc, __cfa_time_t alarm = 0, __cfa_time_t period = 0 ) {
         this->proc = proc;
         this->alarm = alarm;
 …
 void register_self( alarm_node_t * this ) {
+        alarm_list_t * alarms = &event_kernel->alarms;
+        disable_interrupts();
+        verify( !systemProcessor->pending_alarm );
+        lock( &systemProcessor->alarm_lock DEBUG_CTX2 );
+        {
+                verify( validate( &systemProcessor->alarms ) );
+                bool first = !systemProcessor->alarms.head;
+        disable_interrupts();
+        lock( &event_kernel->lock DEBUG_CTX2 );
+        {
+                verify( validate( alarms ) );
+                bool first = !alarms->head;
+                insert( alarms, this );
+                insert( &systemProcessor->alarms, this );
+                if( systemProcessor->pending_alarm ) {
+                        tick_preemption();
+                }
                 if( first ) {
                         __kernel_set_timer( alarms->head->alarm - __kernel_get_time() );
+                        __kernel_set_timer( systemProcessor->alarms.head->alarm - __kernel_get_time() );
+                }
+        }
         unlock( &event_kernel->lock );
+        unlock( &systemProcessor->alarm_lock );
         this->set = true;
         enable_interrupts( DEBUG_CTX );
 …
 void unregister_self( alarm_node_t * this ) {
+        // LIB_DEBUG_PRINT_BUFFER_DECL( STDERR_FILENO, "Kernel : unregister %p start\n", this );
         disable_interrupts();
         lock( &event_kernel->lock DEBUG_CTX2 );
+        lock( &systemProcessor->alarm_lock DEBUG_CTX2 );
+        {
                 verify( validate( &event_kernel->alarms ) );
                 remove( &event_kernel->alarms, this );
+                verify( validate( &systemProcessor->alarms ) );
+                remove( &systemProcessor->alarms, this );
+        }
         unlock( &event_kernel->lock );
+        unlock( &systemProcessor->alarm_lock );
         enable_interrupts( DEBUG_CTX );
         this->set = false;
+        // LIB_DEBUG_PRINT_BUFFER_LOCAL( STDERR_FILENO, "Kernel : unregister %p end\n", this );
+}
-// Local Variables: //
-// mode: c //
-// tab-width: 4 //
-// End: //

src/libcfa/concurrency/alarm.h

-              r0720e049
+              r3d4b23fa
+//                              -*- Mode: CFA -*-
 //
 // Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo
 …
 // Author           : Thierry Delisle
 // Created On       : Fri Jun 2 11:31:25 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 09:59:27 2017
 // Update Count     : 3
+// Last Modified By : Thierry Delisle
+// Last Modified On : --
+// Update Count     : 0
 //
+#pragma once
+#ifndef ALARM_H
+#define ALARM_H
 #include <stdbool.h>
-#include <stdint.h>
+#include <assert.h>
+#include "assert"
+typedef unsigned long int __cfa_time_t;
 struct thread_desc;
 struct processor;
-struct timespec;
-struct itimerval;
-//=============================================================================================
-// time type
-//=============================================================================================
-struct __cfa_time_t {
-        uint64_t val;
-};
-// ctors
-void ?{}( __cfa_time_t * this );
-void ?{}( __cfa_time_t * this, zero_t zero );
-void ?{}( __cfa_time_t * this, timespec * curr );
-void ?{}( itimerval * this, __cfa_time_t * alarm );
-__cfa_time_t ?=?( __cfa_time_t * this, zero_t rhs );
-// logical ops
-static inline bool ?==?( __cfa_time_t lhs, __cfa_time_t rhs ) { return lhs.val == rhs.val; }
-static inline bool ?!=?( __cfa_time_t lhs, __cfa_time_t rhs ) { return lhs.val != rhs.val; }
-static inline bool ?>? ( __cfa_time_t lhs, __cfa_time_t rhs ) { return lhs.val >  rhs.val; }
-static inline bool ?<? ( __cfa_time_t lhs, __cfa_time_t rhs ) { return lhs.val <  rhs.val; }
-static inline bool ?>=?( __cfa_time_t lhs, __cfa_time_t rhs ) { return lhs.val >= rhs.val; }
-static inline bool ?<=?( __cfa_time_t lhs, __cfa_time_t rhs ) { return lhs.val <= rhs.val; }
-static inline bool ?==?( __cfa_time_t lhs, zero_t rhs ) { return lhs.val == rhs; }
-static inline bool ?!=?( __cfa_time_t lhs, zero_t rhs ) { return lhs.val != rhs; }
-static inline bool ?>? ( __cfa_time_t lhs, zero_t rhs ) { return lhs.val >  rhs; }
-static inline bool ?<? ( __cfa_time_t lhs, zero_t rhs ) { return lhs.val <  rhs; }
-static inline bool ?>=?( __cfa_time_t lhs, zero_t rhs ) { return lhs.val >= rhs; }
-static inline bool ?<=?( __cfa_time_t lhs, zero_t rhs ) { return lhs.val <= rhs; }
-// addition/substract
-static inline __cfa_time_t ?+?( __cfa_time_t lhs, __cfa_time_t rhs ) {
-        __cfa_time_t ret;
-        ret.val = lhs.val + rhs.val;
-        return ret;
+}
-static inline __cfa_time_t ?-?( __cfa_time_t lhs, __cfa_time_t rhs ) {
-        __cfa_time_t ret;
-        ret.val = lhs.val - rhs.val;
-        return ret;
+}
-__cfa_time_t from_s ( uint64_t );
-__cfa_time_t from_ms( uint64_t );
-__cfa_time_t from_us( uint64_t );
-__cfa_time_t from_ns( uint64_t );
-extern __cfa_time_t zero_time;
 //=============================================================================================
 // Clock logic
 //=============================================================================================
+#define TIMEGRAN 1_000_000_000L                         // nanosecond granularity, except for timeval
 __cfa_time_t __kernel_get_time();
 …
 typedef alarm_node_t ** __alarm_it_t;
 void ?{}( alarm_node_t * this, thread_desc * thrd, __cfa_time_t alarm = zero_time, __cfa_time_t period = zero_time );
 void ?{}( alarm_node_t * this, processor   * proc, __cfa_time_t alarm = zero_time, __cfa_time_t period = zero_time );
+void ?{}( alarm_node_t * this, thread_desc * thrd, __cfa_time_t alarm = 0, __cfa_time_t period = 0 );
+void ?{}( alarm_node_t * this, processor   * proc, __cfa_time_t alarm = 0, __cfa_time_t period = 0 );
 void ^?{}( alarm_node_t * this );
 …
 void unregister_self( alarm_node_t * this );
+#endif
 // Local Variables: //
 // mode: c //
+// mode: CFA //
 // tab-width: 6 //
 // End: //

src/libcfa/concurrency/coroutine

-              r0720e049
+              r3d4b23fa
 // Author           : Thierry Delisle
 // Created On       : Mon Nov 28 12:27:26 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 09:57:17 2017
 // Update Count     : 2
+// Last Modified By : Thierry Delisle
+// Last Modified On : Mon Nov 28 12:27:26 2016
+// Update Count     : 0
 //
+#pragma once
+#ifndef COROUTINES_H
+#define COROUTINES_H
 #include <assert.h>
+#include "assert"
 #include "invoke.h"
 …
 // Get current coroutine
 extern thread_local coroutine_desc * volatile this_coroutine;
+extern volatile thread_local coroutine_desc * this_coroutine;
 // Private wrappers for context switch and stack creation
 …
+}
+#endif //COROUTINES_H
 // Local Variables: //
 // mode: c //

src/libcfa/concurrency/coroutine.c

-              r0720e049
+              r3d4b23fa
+//                              -*- Mode: CFA -*-
 //
 // Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo
 …
 // Author           : Thierry Delisle
 // Created On       : Mon Nov 28 12:27:26 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Jul 21 22:34:57 2017
 // Update Count     : 1
+// Last Modified By : Thierry Delisle
+// Last Modified On : Mon Nov 28 12:27:26 2016
+// Update Count     : 0
 //
 …
+}
+#include "kernel_private.h"
+#include "kernel"
+#include "libhdr.h"
 #define __CFA_INVOKE_PRIVATE__
 #include "invoke.h"
+extern volatile thread_local processor * this_processor;
 //-----------------------------------------------------------------------------

src/libcfa/concurrency/invoke.c

-              r0720e049
+              r3d4b23fa
+//                              -*- Mode: C -*-
 //
 // Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo
 …
 // Author           : Thierry Delisle
 // Created On       : Tue Jan 17 12:27:26 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Jul 21 22:28:33 2017
 // Update Count     : 1
+// Last Modified By : Thierry Delisle
+// Last Modified On : --
+// Update Count     : 0
 //
 …
 #endif
+}
-// Local Variables: //
-// mode: c //
-// tab-width: 4 //
-// End: //

src/libcfa/concurrency/invoke.h

-              r0720e049
+              r3d4b23fa
+//                              -*- Mode: C -*-
 //
 // Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo
 …
 // Author           : Thierry Delisle
 // Created On       : Tue Jan 17 12:27:26 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Jul 21 22:28:56 2017
 // Update Count     : 1
+// Last Modified By : Thierry Delisle
+// Last Modified On : --
+// Update Count     : 0
 //
 …
+}
 #endif
-// Local Variables: //
-// mode: c //
-// tab-width: 4 //
-// End: //

src/libcfa/concurrency/kernel

-              r0720e049
+              r3d4b23fa
+//                              -*- Mode: CFA -*-
 //
 // Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo
 …
 // Author           : Thierry Delisle
 // Created On       : Tue Jan 17 12:27:26 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 09:58:39 2017
 // Update Count     : 2
+// Last Modified By : Thierry Delisle
+// Last Modified On : --
+// Update Count     : 0
 //
+#pragma once
+#ifndef KERNEL_H
+#define KERNEL_H
 #include <stdbool.h>
 …
 //-----------------------------------------------------------------------------
 // Locks
+void lock      ( spinlock * DEBUG_CTX_PARAM2 );       // Lock the spinlock, spin if already acquired
 void lock_yield( spinlock * DEBUG_CTX_PARAM2 );       // Lock the spinlock, yield repeatedly if already acquired
+bool try_lock  ( spinlock * DEBUG_CTX_PARAM2 );       // Lock the spinlock, return false if already acquired
 void unlock    ( spinlock * );                        // Unlock the spinlock
+bool try_lock  ( spinlock * DEBUG_CTX_PARAM2 );
+void lock      ( spinlock * DEBUG_CTX_PARAM2 );
+void lock_yield( spinlock * DEBUG_CTX_PARAM2 );
+void unlock    ( spinlock * );
 struct semaphore {
 …
 // Cluster
 struct cluster {
+        spinlock ready_queue_lock;                      // Ready queue locks
+        __thread_queue_t ready_queue;                   // Ready queue for threads
+        unsigned long long int preemption;              // Preemption rate on this cluster
+        __thread_queue_t ready_queue;
+        spinlock lock;
 };
 …
 static inline void ^?{}(FinishAction * this) {}
-// Processor
-// Wrapper around kernel threads
 struct processor {
+        // Main state
+        struct processorCtx_t * runner;                 // Coroutine ctx who does keeps the state of the processor
+        cluster * cltr;                                 // Cluster from which to get threads
+        pthread_t kernel_thread;                        // Handle to pthreads
+        struct processorCtx_t * runner;
+        cluster * cltr;
+        pthread_t kernel_thread;
+        // Termination
+        volatile bool do_terminate;                     // Set to true to notify the processor should terminate
+        semaphore terminated;                           // Termination synchronisation
+        semaphore terminated;
+        volatile bool is_terminated;
+        // RunThread data
+        struct FinishAction finish;                     // Action to do after a thread is ran
+        struct FinishAction finish;
+        // Preemption data
+        struct alarm_node_t * preemption_alarm;         // Node which is added in the discrete event simulaiton
+        bool pending_preemption;                        // If true, a preemption was triggered in an unsafe region, the processor must preempt as soon as possible
+        struct alarm_node_t * preemption_alarm;
+        unsigned int preemption;
+#ifdef __CFA_DEBUG__
+        char * last_enable;                             // Last function to enable preemption on this processor
+#endif
+        bool pending_preemption;
+        char * last_enable;
 };
 …
 void ^?{}(processor * this);
+#endif //KERNEL_H
 // Local Variables: //
 // mode: c //
 // tab-width: 4 //
+// mode: CFA //
+// tab-width: 6 //
 // End: //

src/libcfa/concurrency/kernel.c

-              r0720e049
+              r3d4b23fa
+//                              -*- Mode: CFA -*-
 //
 // Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo
 …
 // Author           : Thierry Delisle
 // Created On       : Tue Jan 17 12:27:26 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Jul 21 22:33:18 2017
 // Update Count     : 2
+// Last Modified By : Thierry Delisle
+// Last Modified On : --
+// Update Count     : 0
 //
 …
 //-----------------------------------------------------------------------------
 // Kernel storage
+KERNEL_STORAGE(cluster,           mainCluster);
+KERNEL_STORAGE(processor,         mainProcessor);
+KERNEL_STORAGE(processorCtx_t,    mainProcessorCtx);
+KERNEL_STORAGE(thread_desc,       mainThread);
+#define KERNEL_STORAGE(T,X) static char X##Storage[sizeof(T)]
+KERNEL_STORAGE(processorCtx_t, systemProcessorCtx);
+KERNEL_STORAGE(cluster, systemCluster);
+KERNEL_STORAGE(system_proc_t, systemProcessor);
+KERNEL_STORAGE(thread_desc, mainThread);
 KERNEL_STORAGE(machine_context_t, mainThreadCtx);
 cluster *     mainCluster;
 processor *   mainProcessor;
+cluster * systemCluster;
+system_proc_t * systemProcessor;
 thread_desc * mainThread;
 …
 // Global state
+thread_local coroutine_desc * volatile this_coroutine;
+thread_local thread_desc *    volatile this_thread;
+thread_local processor *      volatile this_processor;
+volatile thread_local processor * this_processor;
+volatile thread_local coroutine_desc * this_coroutine;
+volatile thread_local thread_desc * this_thread;
 volatile thread_local bool preemption_in_progress = 0;
 volatile thread_local unsigned short disable_preempt_count = 1;
 …
         this->limit = (void *)(((intptr_t)this->base) - this->size);
         this->context = &storage_mainThreadCtx;
+        this->context = &mainThreadCtxStorage;
         this->top = this->base;
+}
 …
 void ?{}(processor * this) {
         this{ mainCluster };
+        this{ systemCluster };
+}
 …
         this->cltr = cltr;
         (&this->terminated){ 0 };
         this->do_terminate = false;
+        this->is_terminated = false;
         this->preemption_alarm = NULL;
+        this->preemption = default_preemption();
         this->pending_preemption = false;
 …
         this->cltr = cltr;
         (&this->terminated){ 0 };
         this->do_terminate = false;
+        this->is_terminated = false;
         this->preemption_alarm = NULL;
+        this->preemption = default_preemption();
         this->pending_preemption = false;
         this->kernel_thread = pthread_self();
         this->runner = runner;
         LIB_DEBUG_PRINT_SAFE("Kernel : constructing main processor context %p\n", runner);
+        LIB_DEBUG_PRINT_SAFE("Kernel : constructing system processor context %p\n", runner);
         runner{ this };
+}
+LIB_DEBUG_DO( bool validate( alarm_list_t * this ); )
+void ?{}(system_proc_t * this, cluster * cltr, processorCtx_t * runner) {
+        (&this->alarms){};
+        (&this->alarm_lock){};
+        this->pending_alarm = false;
+        (&this->proc){ cltr, runner };
+        verify( validate( &this->alarms ) );
+}
 void ^?{}(processor * this) {
         if( ! this->do_terminate ) {
+        if( ! this->is_terminated ) {
                 LIB_DEBUG_PRINT_SAFE("Kernel : core %p signaling termination\n", this);
                 this->do_terminate = true;
+                this->is_terminated = true;
                 P( &this->terminated );
                 pthread_join( this->kernel_thread, NULL );
 …
 void ?{}(cluster * this) {
         ( &this->ready_queue ){};
+        ( &this->ready_queue_lock ){};
+        this->preemption = default_preemption();
+        ( &this->lock ){};
+}
 …
                 thread_desc * readyThread = NULL;
                 for( unsigned int spin_count = 0; ! this->do_terminate; spin_count++ )
+                for( unsigned int spin_count = 0; ! this->is_terminated; spin_count++ )
+                {
                         readyThread = nextThread( this->cltr );
 …
         verifyf( thrd->next == NULL, "Expected null got %p", thrd->next );
         lock(   &this_processor->cltr->ready_queue_lock DEBUG_CTX2 );
         append( &this_processor->cltr->ready_queue, thrd );
         unlock( &this_processor->cltr->ready_queue_lock );
+        lock( &systemProcessor->proc.cltr->lock DEBUG_CTX2 );
+        append( &systemProcessor->proc.cltr->ready_queue, thrd );
+        unlock( &systemProcessor->proc.cltr->lock );
         verify( disable_preempt_count > 0 );
 …
 thread_desc * nextThread(cluster * this) {
         verify( disable_preempt_count > 0 );
         lock( &this->ready_queue_lock DEBUG_CTX2 );
+        lock( &this->lock DEBUG_CTX2 );
         thread_desc * head = pop_head( &this->ready_queue );
         unlock( &this->ready_queue_lock );
+        unlock( &this->lock );
         verify( disable_preempt_count > 0 );
         return head;
 …
         // Start by initializing the main thread
         // SKULLDUGGERY: the mainThread steals the process main thread
         // which will then be scheduled by the mainProcessor normally
         mainThread = (thread_desc *)&storage_mainThread;
+        // which will then be scheduled by the systemProcessor normally
+        mainThread = (thread_desc *)&mainThreadStorage;
         current_stack_info_t info;
         mainThread{ &info };
 …
         LIB_DEBUG_PRINT_SAFE("Kernel : Main thread ready\n");
         // Initialize the main cluster
         mainCluster = (cluster *)&storage_mainCluster;
         mainCluster{};
         LIB_DEBUG_PRINT_SAFE("Kernel : main cluster ready\n");
         // Initialize the main processor and the main processor ctx
+        // Initialize the system cluster
+        systemCluster = (cluster *)&systemClusterStorage;
+        systemCluster{};
+        LIB_DEBUG_PRINT_SAFE("Kernel : System cluster ready\n");
+        // Initialize the system processor and the system processor ctx
         // (the coroutine that contains the processing control flow)
+        mainProcessor = (processor *)&storage_mainProcessor;
+        mainProcessor{ mainCluster, (processorCtx_t *)&storage_mainProcessorCtx };
+        systemProcessor = (system_proc_t *)&systemProcessorStorage;
+        systemProcessor{ systemCluster, (processorCtx_t *)&systemProcessorCtxStorage };
+        // Add the main thread to the ready queue
+        // once resume is called on systemProcessor->runner the mainThread needs to be scheduled like any normal thread
+        ScheduleThread(mainThread);
         //initialize the global state variables
         this_processor = mainProcessor;
+        this_processor = &systemProcessor->proc;
         this_thread = mainThread;
         this_coroutine = &mainThread->cor;
+        disable_preempt_count = 1;
         // Enable preemption
         kernel_start_preemption();
+        // Add the main thread to the ready queue
+        // once resume is called on mainProcessor->runner the mainThread needs to be scheduled like any normal thread
+        ScheduleThread(mainThread);
+        // SKULLDUGGERY: Force a context switch to the main processor to set the main thread's context to the current UNIX
+        // SKULLDUGGERY: Force a context switch to the system processor to set the main thread's context to the current UNIX
         // context. Hence, the main thread does not begin through CtxInvokeThread, like all other threads. The trick here is that
         // mainThread is on the ready queue when this call is made.
         resume( mainProcessor->runner );
+        resume( systemProcessor->proc.runner );
 …
         disable_interrupts();
         // SKULLDUGGERY: Notify the mainProcessor it needs to terminates.
+        // SKULLDUGGERY: Notify the systemProcessor it needs to terminates.
         // When its coroutine terminates, it return control to the mainThread
         // which is currently here
         mainProcessor->do_terminate = true;
+        systemProcessor->proc.is_terminated = true;
         suspend();
 …
         kernel_stop_preemption();
         // Destroy the main processor and its context in reverse order of construction
+        // Destroy the system processor and its context in reverse order of construction
         // These were manually constructed so we need manually destroy them
         ^(mainProcessor->runner){};
         ^(mainProcessor){};
+        ^(systemProcessor->proc.runner){};
+        ^(systemProcessor){};
         // Final step, destroy the main thread since it is no longer needed
 …
         return top;
+}
 // Local Variables: //
 // mode: c //

src/libcfa/concurrency/kernel_private.h

-              r0720e049
+              r3d4b23fa
+//                              -*- Mode: CFA -*-
 //
 // Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo
 …
 // Author           : Thierry Delisle
 // Created On       : Mon Feb 13 12:27:26 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 09:58:09 2017
 // Update Count     : 2
+// Last Modified By : Thierry Delisle
+// Last Modified On : --
+// Update Count     : 0
 //
+#pragma once
+#ifndef KERNEL_PRIVATE_H
+#define KERNEL_PRIVATE_H
 #include "libhdr.h"
 …
 extern "C" {
         void disable_interrupts();
         void enable_interrupts_noPoll();
+        void enable_interrupts_noRF();
         void enable_interrupts( DEBUG_CTX_PARAM );
+}
 …
 thread_desc * nextThread(cluster * this);
-//Block current thread and release/wake-up the following resources
 void BlockInternal(void);
 void BlockInternal(spinlock * lock);
 …
 void spin(processor * this, unsigned int * spin_count);
+struct event_kernel_t {
+struct system_proc_t {
+        processor proc;
         alarm_list_t alarms;
+        spinlock lock;
+        spinlock alarm_lock;
+        bool pending_alarm;
 };
+extern event_kernel_t * event_kernel;
+extern thread_local coroutine_desc * volatile this_coroutine;
+extern thread_local thread_desc *    volatile this_thread;
+extern thread_local processor *      volatile this_processor;
+extern cluster * systemCluster;
+extern system_proc_t * systemProcessor;
+extern volatile thread_local processor * this_processor;
+extern volatile thread_local coroutine_desc * this_coroutine;
+extern volatile thread_local thread_desc * this_thread;
 extern volatile thread_local bool preemption_in_progress;
 extern volatile thread_local unsigned short disable_preempt_count;
 …
 extern void ThreadCtxSwitch(coroutine_desc * src, coroutine_desc * dst);
+//-----------------------------------------------------------------------------
+// Utils
+#define KERNEL_STORAGE(T,X) static char storage_##X[sizeof(T)]
+#endif //KERNEL_PRIVATE_H
 // Local Variables: //

src/libcfa/concurrency/monitor

-              r0720e049
+              r3d4b23fa
+//                              -*- Mode: CFA -*-
 //
 // Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo
 …
 // Author           : Thierry Delisle
 // Created On       : Thd Feb 23 12:27:26 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 09:59:01 2017
 // Update Count     : 3
+// Last Modified By : Thierry Delisle
+// Last Modified On : --
+// Update Count     : 0
 //
+#pragma once
+#ifndef MONITOR_H
+#define MONITOR_H
 #include <stddef.h>
 #include <assert.h>
+#include "assert"
 #include "invoke.h"
 #include "stdlib"
 …
 void __accept_internal( unsigned short count, __acceptable_t * acceptables, void (*func)(void) );
+// Local Variables: //
+// mode: c //
+// tab-width: 4 //
+// End: //
+#endif //MONITOR_H

src/libcfa/concurrency/monitor.c

-              r0720e049
+              r3d4b23fa
+//                              -*- Mode: CFA -*-
 //
 // Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo
 …
 // Author           : Thierry Delisle
 // Created On       : Thd Feb 23 12:27:26 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Mon Jul 31 14:59:05 2017
 // Update Count     : 3
+// Last Modified By : Thierry Delisle
+// Last Modified On : --
+// Update Count     : 0
 //
 …
         if( !this->monitors ) {
                 // LIB_DEBUG_PRINT_SAFE("Branding\n");
                 assertf( thrd->current_monitors != NULL, "No current monitor to brand condition %p", thrd->current_monitors );
+                assertf( thrd->current_monitors != NULL, "No current monitor to brand condition", thrd->current_monitors );
                 this->monitor_count = thrd->current_monitor_count;
 …
         return head;
+}
-// Local Variables: //
-// mode: c //
-// tab-width: 4 //
-// End: //

src/libcfa/concurrency/preemption.c

-              r0720e049
+              r3d4b23fa
+//                              -*- Mode: CFA -*-
 //
 // Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo
 …
 // Author           : Thierry Delisle
 // Created On       : Mon Jun 5 14:20:42 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Jul 21 22:36:05 2017
 // Update Count     : 2
+// Last Modified By : Thierry Delisle
+// Last Modified On : --
+// Update Count     : 0
 //
 …
 #endif
-//TODO move to defaults
 #define __CFA_DEFAULT_PREEMPTION__ 10000
-//TODO move to defaults
 __attribute__((weak)) unsigned int default_preemption() {
         return __CFA_DEFAULT_PREEMPTION__;
+}
-// Short hands for signal context information
 #define __CFA_SIGCXT__ ucontext_t *
 #define __CFA_SIGPARMS__ __attribute__((unused)) int sig, __attribute__((unused)) siginfo_t *sfp, __attribute__((unused)) __CFA_SIGCXT__ cxt
-// FwdDeclarations : timeout handlers
 static void preempt( processor   * this );
 static void timeout( thread_desc * this );
-// FwdDeclarations : Signal handlers
 void sigHandler_ctxSwitch( __CFA_SIGPARMS__ );
+void sigHandler_alarm    ( __CFA_SIGPARMS__ );
 void sigHandler_segv     ( __CFA_SIGPARMS__ );
 void sigHandler_abort    ( __CFA_SIGPARMS__ );
-// FwdDeclarations : sigaction wrapper
 static void __kernel_sigaction( int sig, void (*handler)(__CFA_SIGPARMS__), int flags );
+// FwdDeclarations : alarm thread main
+void * alarm_loop( __attribute__((unused)) void * args );
+// Machine specific register name
+LIB_DEBUG_DO( bool validate( alarm_list_t * this ); )
 #ifdef __x86_64__
 #define CFA_REG_IP REG_RIP
 …
 #endif
-KERNEL_STORAGE(event_kernel_t, event_kernel);         // private storage for event kernel
-event_kernel_t * event_kernel;                        // kernel public handle to even kernel
-static pthread_t alarm_thread;                        // pthread handle to alarm thread
-void ?{}(event_kernel_t * this) {
-        (&this->alarms){};
-        (&this->lock){};
+}
 //=============================================================================================
 …
 //=============================================================================================
-// Get next expired node
-static inline alarm_node_t * get_expired( alarm_list_t * alarms, __cfa_time_t currtime ) {
-        if( !alarms->head ) return NULL;                          // If no alarms return null
-        if( alarms->head->alarm >= currtime ) return NULL;        // If alarms head not expired return null
-        return pop(alarms);                                       // Otherwise just pop head
+}
-// Tick one frame of the Discrete Event Simulation for alarms
 void tick_preemption() {
         alarm_node_t * node = NULL;                     // Used in the while loop but cannot be declared in the while condition
+        alarm_list_t * alarms = &event_kernel->alarms;  // Local copy for ease of reading
         __cfa_time_t currtime = __kernel_get_time();    // Check current time once so we everything "happens at once"
         //Loop throught every thing expired
         while( node = get_expired( alarms, currtime ) ) {
+                // Check if this is a kernel
+        // LIB_DEBUG_PRINT_BUFFER_DECL( STDERR_FILENO, "Ticking preemption\n" );
+        alarm_list_t * alarms = &systemProcessor->alarms;
+        __cfa_time_t currtime = __kernel_get_time();
+        while( alarms->head && alarms->head->alarm < currtime ) {
+                alarm_node_t * node = pop(alarms);
+                // LIB_DEBUG_PRINT_BUFFER_LOCAL( STDERR_FILENO, "Ticking %p\n", node );
                 if( node->kernel_alarm ) {
                         preempt( node->proc );
 …
+                }
                 // Check if this is a periodic alarm
+                __cfa_time_t period = node->period;
                 if( period > 0 ) {
                         node->alarm = currtime + period;    // Alarm is periodic, add currtime to it (used cached current time)
                         insert( alarms, node );             // Reinsert the node for the next time it triggers
+                verify( validate( alarms ) );
+                if( node->period > 0 ) {
+                        node->alarm = currtime + node->period;
+                        insert( alarms, node );
+                }
                 else {
+                        node->set = false;                  // Node is one-shot, just mark it as not pending
+                }
+        }
+        // If there are still alarms pending, reset the timer
+        if( alarms->head ) { __kernel_set_timer( alarms->head->alarm - currtime ); }
+}
+// Update the preemption of a processor and notify interested parties
+                        node->set = false;
+                }
+        }
+        if( alarms->head ) {
+                __kernel_set_timer( alarms->head->alarm - currtime );
+        }
+        verify( validate( alarms ) );
+        // LIB_DEBUG_PRINT_BUFFER_LOCAL( STDERR_FILENO, "Ticking preemption done\n" );
+}
 void update_preemption( processor * this, __cfa_time_t duration ) {
+        LIB_DEBUG_PRINT_BUFFER_DECL( STDERR_FILENO, "Processor : %p updating preemption to %lu\n", this, duration );
         alarm_node_t * alarm = this->preemption_alarm;
+        duration *= 1000;
         // Alarms need to be enabled
 …
 extern "C" {
-        // Disable interrupts by incrementing the counter
         void disable_interrupts() {
                 __attribute__((unused)) unsigned short new_val = __atomic_add_fetch_2( &disable_preempt_count, 1, __ATOMIC_SEQ_CST );
+                verify( new_val < 65_000u );              // If this triggers someone is disabling interrupts without enabling them
+        }
+        // Enable interrupts by decrementing the counter
+        // If counter reaches 0, execute any pending CtxSwitch
+                verify( new_val < (unsigned short)65_000 );
+                verify( new_val != (unsigned short) 0 );
+        }
+        void enable_interrupts_noRF() {
+                __attribute__((unused)) unsigned short prev = __atomic_fetch_add_2( &disable_preempt_count, -1, __ATOMIC_SEQ_CST );
+                verify( prev != (unsigned short) 0 );
+        }
         void enable_interrupts( DEBUG_CTX_PARAM ) {
+                processor * proc   = this_processor;      // Cache the processor now since interrupts can start happening after the atomic add
+                thread_desc * thrd = this_thread;         // Cache the thread now since interrupts can start happening after the atomic add
+                processor * proc   = this_processor;
+                thread_desc * thrd = this_thread;
                 unsigned short prev = __atomic_fetch_add_2( &disable_preempt_count, -1, __ATOMIC_SEQ_CST );
+                verify( prev != 0u );                     // If this triggers someone is enabled already enabled interruptsverify( prev != 0u );
+                // Check if we need to prempt the thread because an interrupt was missed
+                verify( prev != (unsigned short) 0 );
                 if( prev == 1 && proc->pending_preemption ) {
                         proc->pending_preemption = false;
 …
+                }
-                // For debugging purposes : keep track of the last person to enable the interrupts
                 LIB_DEBUG_DO( proc->last_enable = caller; )
+        }
+        // Disable interrupts by incrementint the counter
+        // Don't execute any pending CtxSwitch even if counter reaches 0
+        void enable_interrupts_noPoll() {
+                __attribute__((unused)) unsigned short prev = __atomic_fetch_add_2( &disable_preempt_count, -1, __ATOMIC_SEQ_CST );
+                verify( prev != 0u );                     // If this triggers someone is enabled already enabled interrupts
+        }
+}
+// sigprocmask wrapper : unblock a single signal
+}
 static inline void signal_unblock( int sig ) {
         sigset_t mask;
 …
+}
-// sigprocmask wrapper : block a single signal
 static inline void signal_block( int sig ) {
         sigset_t mask;
 …
+}
+// kill wrapper : signal a processor
+static inline bool preemption_ready() {
+        return disable_preempt_count == 0 && !preemption_in_progress;
+}
+static inline void defer_ctxSwitch() {
+        this_processor->pending_preemption = true;
+}
+static inline void defer_alarm() {
+        systemProcessor->pending_alarm = true;
+}
 static void preempt( processor * this ) {
         pthread_kill( this->kernel_thread, SIGUSR1 );
+}
-// reserved for future use
 static void timeout( thread_desc * this ) {
         //TODO : implement waking threads
+}
-// Check if a CtxSwitch signal handler shoud defer
-// If true  : preemption is safe
-// If false : preemption is unsafe and marked as pending
-static inline bool preemption_ready() {
-        bool ready = disable_preempt_count == 0 && !preemption_in_progress; // Check if preemption is safe
-        this_processor->pending_preemption = !ready;                        // Adjust the pending flag accordingly
-        return ready;
+}
 //=============================================================================================
 // Kernel Signal Startup/Shutdown logic
 //=============================================================================================
+// Startup routine to activate preemption
+// Called from kernel_startup
+static pthread_t alarm_thread;
+void * alarm_loop( __attribute__((unused)) void * args );
 void kernel_start_preemption() {
         LIB_DEBUG_PRINT_SAFE("Kernel : Starting preemption\n");
+        // Start with preemption disabled until ready
+        disable_preempt_count = 1;
+        // Initialize the event kernel
+        event_kernel = (event_kernel_t *)&storage_event_kernel;
+        event_kernel{};
+        // Setup proper signal handlers
+        __kernel_sigaction( SIGUSR1, sigHandler_ctxSwitch, SA_SIGINFO );         // CtxSwitch handler
+        // __kernel_sigaction( SIGSEGV, sigHandler_segv     , SA_SIGINFO );      // Failure handler
+        // __kernel_sigaction( SIGBUS , sigHandler_segv     , SA_SIGINFO );      // Failure handler
+        __kernel_sigaction( SIGUSR1, sigHandler_ctxSwitch, SA_SIGINFO );
+        // __kernel_sigaction( SIGSEGV, sigHandler_segv     , SA_SIGINFO );
+        // __kernel_sigaction( SIGBUS , sigHandler_segv     , SA_SIGINFO );
         signal_block( SIGALRM );
 …
+}
-// Shutdown routine to deactivate preemption
-// Called from kernel_shutdown
 void kernel_stop_preemption() {
         LIB_DEBUG_PRINT_SAFE("Kernel : Preemption stopping\n");
-        // Block all signals since we are already shutting down
         sigset_t mask;
         sigfillset( &mask );
         sigprocmask( SIG_BLOCK, &mask, NULL );
-        // Notify the alarm thread of the shutdown
         sigval val = { 1 };
         pthread_sigqueue( alarm_thread, SIGALRM, val );
-        // Wait for the preemption thread to finish
         pthread_join( alarm_thread, NULL );
-        // Preemption is now fully stopped
         LIB_DEBUG_PRINT_SAFE("Kernel : Preemption stopped\n");
+}
-// Raii ctor/dtor for the preemption_scope
-// Used by thread to control when they want to receive preemption signals
 void ?{}( preemption_scope * this, processor * proc ) {
         (&this->alarm){ proc, zero_time, zero_time };
+        (&this->alarm){ proc };
         this->proc = proc;
         this->proc->preemption_alarm = &this->alarm;
+        update_preemption( this->proc, from_us(this->proc->cltr->preemption) );
+        update_preemption( this->proc, this->proc->preemption );
+}
 …
         disable_interrupts();
         update_preemption( this->proc, zero_time );
+        update_preemption( this->proc, 0 );
+}
 …
 //=============================================================================================
-// Context switch signal handler
-// Receives SIGUSR1 signal and causes the current thread to yield
 void sigHandler_ctxSwitch( __CFA_SIGPARMS__ ) {
         LIB_DEBUG_DO( last_interrupt = (void *)(cxt->uc_mcontext.gregs[CFA_REG_IP]); )
+        // Check if it is safe to preempt here
+        if( !preemption_ready() ) { return; }
+        preemption_in_progress = true;                      // Sync flag : prevent recursive calls to the signal handler
+        signal_unblock( SIGUSR1 );                          // We are about to CtxSwitch out of the signal handler, let other handlers in
+        preemption_in_progress = false;                     // Clear the in progress flag
+        // Preemption can occur here
+        BlockInternal( (thread_desc*)this_thread );         // Do the actual CtxSwitch
+}
+// Main of the alarm thread
+// Waits on SIGALRM and send SIGUSR1 to whom ever needs it
+        if( preemption_ready() ) {
+                preemption_in_progress = true;
+                signal_unblock( SIGUSR1 );
+                this_processor->pending_preemption = false;
+                preemption_in_progress = false;
+                BlockInternal( (thread_desc*)this_thread );
+        }
+        else {
+                defer_ctxSwitch();
+        }
+}
 void * alarm_loop( __attribute__((unused)) void * args ) {
-        // Block sigalrms to control when they arrive
         sigset_t mask;
         sigemptyset( &mask );
 …
+        }
-        // Main loop
         while( true ) {
-                // Wait for a sigalrm
                 siginfo_t info;
                 int sig = sigwaitinfo( &mask, &info );
+                // If another signal arrived something went wrong
+                assertf(sig == SIGALRM, "Kernel Internal Error, sigwait: Unexpected signal %d (%d : %d)\n", sig, info.si_code, info.si_value.sival_int);
+                LIB_DEBUG_PRINT_SAFE("Kernel : Caught alarm from %d with %d\n", info.si_code, info.si_value.sival_int );
+                // Switch on the code (a.k.a. the sender) to
+                switch( info.si_code )
+                if( sig < 0 ) {
+                        abortf( "internal error, sigwait" );
+                }
+                else if( sig == SIGALRM )
+                {
+                // Timers can apparently be marked as sent for the kernel
+                // In either case, tick preemption
+                case SI_TIMER:
+                case SI_KERNEL:
+                        LIB_DEBUG_PRINT_SAFE("Kernel : Preemption thread tick\n");
+                        lock( &event_kernel->lock DEBUG_CTX2 );
+                        tick_preemption();
+                        unlock( &event_kernel->lock );
+                        break;
+                // Signal was not sent by the kernel but by an other thread
+                case SI_QUEUE:
+                        // For now, other thread only signal the alarm thread to shut it down
+                        // If this needs to change use info.si_value and handle the case here
+                        goto EXIT;
+                }
+        }
+EXIT:
+                        LIB_DEBUG_PRINT_SAFE("Kernel : Caught signal %d (%d)\n", sig, info.si_value.sival_int );
+                        if( info.si_value.sival_int == 0 )
+                        {
+                                LIB_DEBUG_PRINT_SAFE("Kernel : Preemption thread tick\n");
+                                lock( &systemProcessor->alarm_lock DEBUG_CTX2 );
+                                tick_preemption();
+                                unlock( &systemProcessor->alarm_lock );
+                        }
+                        else if( info.si_value.sival_int == 1 )
+                        {
+                                break;
+                        }
+                }
+                else
+                {
+                        LIB_DEBUG_PRINT_SAFE("Kernel : Unexpected signal %d (%d)\n", sig, info.si_value.sival_int);
+                }
+        }
         LIB_DEBUG_PRINT_SAFE("Kernel : Preemption thread stopping\n");
         return NULL;
+}
-// Sigaction wrapper : register an signal handler
 static void __kernel_sigaction( int sig, void (*handler)(__CFA_SIGPARMS__), int flags ) {
         struct sigaction act;
 …
+}
+// Sigaction wrapper : restore default handler
+typedef void (*sa_handler_t)(int);
 static void __kernel_sigdefault( int sig ) {
         struct sigaction act;
         act.sa_handler = SIG_DFL;
+        // act.sa_handler = SIG_DFL;
         act.sa_flags = 0;
         sigemptyset( &act.sa_mask );
 …
 //      raise( SIGABRT );
 // }
-// Local Variables: //
-// mode: c //
-// tab-width: 4 //
-// End: //

src/libcfa/concurrency/preemption.h

-              r0720e049
+              r3d4b23fa
+//                              -*- Mode: CFA -*-
 //
 // Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo
 …
 // Author           : Thierry Delisle
 // Created On       : Mon Jun 5 14:20:42 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Jul 21 22:34:25 2017
 // Update Count     : 1
+// Last Modified By : Thierry Delisle
+// Last Modified On : --
+// Update Count     : 0
 //
+#pragma once
+#ifndef PREEMPTION_H
+#define PREEMPTION_H
 #include "alarm.h"
 …
 void ^?{}( preemption_scope * this );
+// Local Variables: //
+// mode: c //
+// tab-width: 4 //
+// End: //
+#endif //PREEMPTION_H

src/libcfa/concurrency/thread

-              r0720e049
+              r3d4b23fa
+//                              -*- Mode: CFA -*-
 //
 // Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo
 …
 // Author           : Thierry Delisle
 // Created On       : Tue Jan 17 12:27:26 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 09:59:40 2017
 // Update Count     : 3
+// Last Modified By : Thierry Delisle
+// Last Modified On : --
+// Update Count     : 0
 //
+#pragma once
+#ifndef THREADS_H
+#define THREADS_H
 #include <assert.h>
+#include "assert"
 #include "invoke.h"
 …
+}
 extern thread_local thread_desc * volatile this_thread;
+extern volatile thread_local thread_desc * this_thread;
 forall( dtype T | is_thread(T) )
 …
 void yield( unsigned times );
+#endif //THREADS_H
 // Local Variables: //
 // mode: c //

src/libcfa/concurrency/thread.c

-              r0720e049
+              r3d4b23fa
+//                              -*- Mode: CFA -*-
 //
 // Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo
 …
 // Author           : Thierry Delisle
 // Created On       : Tue Jan 17 12:27:26 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Jul 21 22:34:46 2017
 // Update Count     : 1
+// Last Modified By : Thierry Delisle
+// Last Modified On : --
+// Update Count     : 0
 //
 …
 void yield( void ) {
         BlockInternal( this_thread );
+        BlockInternal( (thread_desc *)this_thread );
+}

src/libcfa/containers/maybe

-              r0720e049
+              r3d4b23fa
 // Author           : Andrew Beach
 // Created On       : Wed May 24 14:43:00 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 10:00:52 2017
 // Update Count     : 4
+// Last Modified By : Andrew Beach
+// Last Modified On : Fri Jun 16 15:42:00 2017
+// Update Count     : 2
 //
+#pragma once
+#ifndef MAYBE_H
+#define MAYBE_H
 #include <stdbool.h>
 …
 void set_none(maybe(T) * this);
+// Local Variables: //
+// mode: c //
+// tab-width: 4 //
+// End: //
+#endif // MAYBE_H

src/libcfa/containers/maybe.c

-              r0720e049
+              r3d4b23fa
 // Author           : Andrew Beach
 // Created On       : Wed May 24 15:40:00 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Jul 20 15:23:50 2017
 // Update Count     : 2
+// Last Modified By : Andrew Beach
+// Last Modified On : Thr May 25 15:24:00 2017
+// Update Count     : 1
 //
 #include <containers/maybe>
 #include <assert.h>
+#include <assert>

src/libcfa/containers/pair

-              r0720e049
+              r3d4b23fa
 // Author           : Aaron Moss
 // Created On       : Wed Apr 12 15:32:00 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 09:59:53 2017
 // Update Count     : 2
+// Last Modified By : Aaron Moss
+// Last Modified On : Wed Apr 12 15:32:00 2017
+// Update Count     : 1
 //
+#pragma once
+#ifndef PAIR_H
+#define PAIR_H
 forall(otype R, otype S) struct pair {
 …
 int ?>=?(pair(R, S) p, pair(R, S) q);
+#endif // PAIR_H
 // Local Variables: //
 // mode: c //

src/libcfa/containers/result

-              r0720e049
+              r3d4b23fa
 // Author           : Andrew Beach
 // Created On       : Wed May 24 14:45:00 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 10:00:44 2017
 // Update Count     : 3
+// Last Modified By : Andrew Beach
+// Last Modified On : Fri Jun 16 15:41:00 2017
+// Update Count     : 2
 //
+#pragma once
+#ifndef RESULT_H
+#define RESULT_H
 #include <stdbool.h>
 …
 void set_error(result(T, E) * this, E error);
+// Local Variables: //
+// mode: c //
+// tab-width: 4 //
+// End: //
+#endif // RESULT_H

src/libcfa/containers/result.c

-              r0720e049
+              r3d4b23fa
 // Author           : Andrew Beach
 // Created On       : Wed May 24 15:40:00 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Jul 20 15:23:58 2017
 // Update Count     : 2
+// Last Modified By : Andrew Beach
+// Last Modified On : Thr May 25 15:27:00 2017
+// Update Count     : 1
 //
 #include <containers/result>
 #include <assert.h>
+#include <assert>

src/libcfa/containers/vector

-              r0720e049
+              r3d4b23fa
 // Created On       : Tue Jul  5 18:00:07 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 10:01:18 2017
 // Update Count     : 3
+// Last Modified On : Tue Jul  5 18:01:35 2016
+// Update Count     : 2
 //
+#pragma once
+#ifndef VECTOR_H
+#define VECTOR_H
 extern "C" {
 …
 // }
+#endif // VECTOR_H
 // Local Variables: //
 // mode: c //

src/libcfa/exception.c

-              r0720e049
+              r3d4b23fa
 // Created On       : Mon Jun 26 15:13:00 2017
 // Last Modified By : Andrew Beach
+// Last Modified On : Fri Aug  4 15:20:00 2017
+// Update Count     : 6
+//
+#include <stddef.h> // for size_t
+// Last Modified On : Tus Jul 11 16:36:00 2017
+// Update Count     : 1
+//
 #include "exception.h"
 …
 #include <unwind.h>
-// FIX ME: temporary hack to keep ARM build working
-#ifndef _URC_FATAL_PHASE1_ERROR
-#define _URC_FATAL_PHASE1_ERROR 2
-#endif // ! _URC_FATAL_PHASE1_ERROR
-#ifndef _URC_FATAL_PHASE2_ERROR
-#define _URC_FATAL_PHASE2_ERROR 2
-#endif // ! _URC_FATAL_PHASE2_ERROR
 #include "lsda.h"
-// Base exception vtable is abstract, you should not have base exceptions.
-struct __cfaehm__base_exception_t_vtable
-                ___cfaehm__base_exception_t_vtable_instance = {
-        .parent = NULL,
-        .size = 0,
-        .copy = NULL,
-        .free = NULL,
-        .msg = NULL
-};
 // Temperary global exception context. Does not work with concurency.
 struct exception_context_t {
+struct shared_stack_t {
     struct __cfaehm__try_resume_node * top_resume;
     struct __cfaehm__try_resume_node * current_resume;
     exception * current_exception;
+    exception current_exception;
     int current_handler_index;
 } shared_stack = {NULL, NULL, 0, 0};
+// Get the current exception context.
+// There can be a single global until multithreading occurs, then each stack
+// needs its own. It will have to be updated to handle that.
+struct exception_context_t * this_exception_context() {
+        return &shared_stack;
+}
+//#define SAVE_EXCEPTION_CONTEXT(to_name)
+//struct exception_context_t * to_name = this_exception_context();
+//exception * this_exception() {
+//    return this_exception_context()->current_exception;
+//}
+// This macro should be the only thing that needs to change across machines.  Used in the personality function, way down
+// in termination.
+// This macro should be the only thing that needs to change across machines.
+// Used in the personality function, way down in termination.
 // struct _Unwind_Context * -> _Unwind_Reason_Code(*)(exception *)
 #define MATCHER_FROM_CONTEXT(ptr_to_context) \
 …
         // DEBUG
         printf("Throwing resumption exception\n");
+        printf("Throwing resumption exception %d\n", *except);
         struct __cfaehm__try_resume_node * original_head = shared_stack.current_resume;
 …
+        }
         printf("Unhandled exception\n");
+        printf("Unhandled exception %d\n", *except);
         shared_stack.current_resume = original_head;
 …
+}
+// Do we control where exceptions get thrown even with concurency?  If not these are not quite thread safe, the cleanup
+// hook has to be added after the node is built but before it is made the top node.
+/* Do we control where exceptions get thrown even with concurency?
+ * If not these are not quite thread safe, the cleanup hook has to be added
+ * after the node is built but before it is made the top node.
+ */
 void __cfaehm__try_resume_setup(struct __cfaehm__try_resume_node * node,
                         int (*handler)(exception * except)) {
 …
 // TERMINATION ===============================================================
+// MEMORY MANAGEMENT (still for integers)
+// May have to move to cfa for constructors and destructors (references).
+struct __cfaehm__node {
+        struct __cfaehm__node * next;
+};
+#define NODE_TO_EXCEPT(node) ((exception *)(1 + (node)))
+#define EXCEPT_TO_NODE(except) ((struct __cfaehm__node *)(except) - 1)
+// Creates a copy of the indicated exception and sets current_exception to it.
+static void __cfaehm__allocate_exception( exception * except ) {
+        struct exception_context_t * context = this_exception_context();
+        // Allocate memory for the exception.
+        struct __cfaehm__node * store = malloc(
+                sizeof( struct __cfaehm__node ) + except->virtual_table->size );
+        if ( ! store ) {
+                // Failure: cannot allocate exception. Terminate thread.
+                abort(); // <- Although I think it might be the process.
+        }
+        // Add the node to the list:
+        store->next = EXCEPT_TO_NODE(context->current_exception);
+        context->current_exception = NODE_TO_EXCEPT(store);
+        // Copy the exception to storage.
+        except->virtual_table->copy( context->current_exception, except );
+}
+// Delete the provided exception, unsetting current_exception if relivant.
+static void __cfaehm__delete_exception( exception * except ) {
+        struct exception_context_t * context = this_exception_context();
+        // DEBUG
+        printf( "Deleting Exception\n");
+        // Remove the exception from the list.
+        struct __cfaehm__node * to_free = EXCEPT_TO_NODE(except);
+        struct __cfaehm__node * node;
+        if ( context->current_exception == except ) {
+                node = to_free->next;
+                context->current_exception = (node) ? NODE_TO_EXCEPT(node) : 0;
+        } else {
+                node = EXCEPT_TO_NODE(context->current_exception);
+                // It may always be in the first or second position.
+                while( to_free != node->next ) {
+                        node = node->next;
+                }
+                node->next = to_free->next;
+        }
+        // Free the old exception node.
+        except->virtual_table->free( except );
+        free( to_free );
+}
+// If this isn't a rethrow (*except==0), delete the provided exception.
+void __cfaehm__cleanup_terminate( void * except ) {
+        if ( *(void**)except ) __cfaehm__delete_exception( *(exception**)except );
+}
+// Requires -fexceptions to work.
+// Global which defines the current exception
+// Currently an int just to make matching easier
+//int this_exception; (became shared_stack.current_exception)
 // We need a piece of storage to raise the exception
 …
+}
+// The exception that is being thrown must already be stored.
+__attribute__((noreturn)) void __cfaehm__begin_unwind(void) {
+        if ( ! this_exception_context()->current_exception ) {
+                printf("UNWIND ERROR missing exception in begin unwind\n");
+                abort();
+        }
+void __cfaehm__throw_terminate( exception * val ) {
+        // Store the current exception
+        shared_stack.current_exception = *val;
+        // DEBUG
+        printf("Throwing termination exception %d\n", *val);
         // Call stdlibc to raise the exception
         _Unwind_Reason_Code ret = _Unwind_RaiseException( &this_exception_storage );
+        // If we reach here it means something happened.  For resumption to work we need to find a way to return back to
+        // here.  Most of them will probably boil down to setting a global flag and making the phase 1 either stop or
+        // fail.  Causing an error on purpose may help avoiding unnecessary work but it might have some weird side
+        // effects.  If we just pretend no handler was found that would work but may be expensive for no reason since we
+        // will always search the whole stack.
+        // If we reach here it means something happened
+        // For resumption to work we need to find a way to return back to here
+        // Most of them will probably boil down to setting a global flag and making the phase 1 either stop or fail.
+        // Causing an error on purpose may help avoiding unnecessary work but it might have some weird side effects.
+        // If we just pretend no handler was found that would work but may be expensive for no reason since we will always
+        // search the whole stack
         if( ret == _URC_END_OF_STACK ) {
+                // No proper handler was found.  This can be handled in several way.  C++ calls std::terminate Here we
+                // force unwind the stack, basically raising a cancellation.
+                // No proper handler was found
+                // This can be handled in several way
+                // C++ calls std::terminate
+                // Here we force unwind the stack, basically raising a cancellation
                 printf("Uncaught exception %p\n", &this_exception_storage);
 …
+        }
+        // We did not simply reach the end of the stack without finding a handler.  Something wen't wrong
+        // We did not simply reach the end of the stack without finding a handler,
+        // Something wen't wrong
         printf("UNWIND ERROR %d after raise exception\n", ret);
         abort();
+}
+void __cfaehm__throw_terminate( exception * val ) {
+        // DEBUG
+        printf("Throwing termination exception\n");
+        __cfaehm__allocate_exception( val );
+        __cfaehm__begin_unwind();
+}
+// Nesting this the other way would probably be faster.
 void __cfaehm__rethrow_terminate(void) {
         // DEBUG
         printf("Rethrowing termination exception\n");
+        __cfaehm__begin_unwind();
+}
+// This is our personality routine.  For every stack frame anotated with ".cfi_personality 0x3,__gcfa_personality_v0".
+// This function will be called twice when unwinding.  Once in the search phased and once in the cleanup phase.
+        __cfaehm__throw_terminate(&shared_stack.current_exception);
+}
+// This is our personality routine
+// For every stack frame anotated with ".cfi_personality 0x3,__gcfa_personality_v0"
+// This function will be called twice when unwinding
+// Once in the search phased and once in the cleanup phase
 _Unwind_Reason_Code __gcfa_personality_v0 (
                 int version, _Unwind_Action actions, unsigned long long exceptionClass,
 …
                                         _Unwind_Reason_Code (*matcher)(exception *) =
                                                 MATCHER_FROM_CONTEXT(context);
                                         int index = matcher(shared_stack.current_exception);
+                                        int index = matcher(&shared_stack.current_exception);
                                         _Unwind_Reason_Code ret = (0 == index)
                                                 ? _URC_CONTINUE_UNWIND : _URC_HANDLER_FOUND;
 …
                                 // I assume this sets the instruction pointer to the adress of the landing pad
                                 // It doesn't actually set it, it only state the value that needs to be set once we return _URC_INSTALL_CONTEXT
                                 _Unwind_SetIP( context, ((lsd_info.LPStart) + (callsite_landing_pad)) );
+                                _Unwind_SetIP( context, lsd_info.LPStart + callsite_landing_pad );
                                 // DEBUG
 …
+}
+// Try statements are hoisted out see comments for details.  With this could probably be unique and simply linked from
+// libcfa but there is one problem left, see the exception table for details
+// Try statements are hoisted out see comments for details
+// With this could probably be unique and simply linked from
+// libcfa but there is one problem left, see the exception table
+// for details
 __attribute__((noinline))
 void __cfaehm__try_terminate(void (*try_block)(),
 …
         //! printf("%p %p %p %p\n", &try_block, &catch_block, &match_block, &xy);
+        // Setup statments: These 2 statments won't actually result in any code, they only setup global tables.
+        // However, they clobber gcc cancellation support from gcc.  We can replace the personality routine but
+        // replacing the exception table gcc generates is not really doable, it generates labels based on how the
+        // assembly works.
+        // Setup statments
+        // These 2 statments won't actually result in any code,
+        // they only setup global tables.
+        // However, they clobber gcc cancellation support from gcc.
+        // We can replace the personality routine but replacing the exception
+        // table gcc generates is not really doable, it generates labels based
+        // on how the assembly works.
         // Setup the personality routine
         asm volatile (".cfi_personality 0x3,__gcfa_personality_v0");
 …
         asm volatile (".cfi_lsda 0x3, .LLSDACFA2");
         // Label which defines the start of the area for which the handler is setup.
+        // Label which defines the start of the area for which the handler is setup
         asm volatile (".TRYSTART:");
 …
         // Exceptionnal path
         CATCH : __attribute__(( unused ));
         // Label which defines the end of the area for which the handler is setup.
+        // Label which defines the end of the area for which the handler is setup
         asm volatile (".TRYEND:");
+        // Label which defines the start of the exception landing pad.  Basically what is called when the exception is
+        // caught.  Note, if multiple handlers are given, the multiplexing should be done by the generated code, not the
+        // exception runtime.
+        // Label which defines the start of the exception landing pad
+        // basically what will be called when the exception is caught
+        // Note, if multiple handlers are given, the multiplexing should be done
+        // by the generated code, not the exception runtime
         asm volatile (".CATCH:");
         // Exception handler
+        catch_block( shared_stack.current_handler_index,
+                     shared_stack.current_exception );
+}
+// Exception table data we need to generate.  While this is almost generic, the custom data refers to foo_try_match try
+// match, which is no way generic.  Some more works need to be done if we want to have a single call to the try routine.
+#if defined( __x86_64__ ) || defined( __i386__ )
+        catch_block(shared_stack.current_handler_index,
+                    &shared_stack.current_exception);
+}
+// Exception table data we need to generate
+// While this is almost generic, the custom data refers to
+// foo_try_match try match, which is no way generic
+// Some more works need to be done if we want to have a single
+// call to the try routine
 asm (
         //HEADER
 …
 //      "       .section        .note.GNU-stack,\"x\",@progbits\n"
 );
-#endif // __x86_64__ || __i386__

src/libcfa/exception.h

-              r0720e049
+              r3d4b23fa
 // Created On       : Mon Jun 26 15:11:00 2017
 // Last Modified By : Andrew Beach
 // Last Modified On : Fri Aug  4 15:20:00 2017
 // Update Count     : 5
+// Last Modified On : Tus Jul 11 16:31:00 2017
+// Update Count     : 2
 //
+#pragma once
+#ifndef EXCEPTION_H
+#define EXCEPTION_H
+// Later to be a special structure type.
+typedef int exception;
 #ifdef __CFORALL__
 extern "C" {
 #endif
-struct __cfaehm__base_exception_t;
-typedef struct __cfaehm__base_exception_t exception;
-struct __cfaehm__base_exception_t_vtable {
-        const struct __cfaehm__base_exception_t_vtable * parent;
-        size_t size;
-        void (*copy)(struct __cfaehm__base_exception_t *this,
-                     struct __cfaehm__base_exception_t * other);
-        void (*free)(struct __cfaehm__base_exception_t *this);
-        const char (*msg)(struct __cfaehm__base_exception_t *this);
-};
-struct __cfaehm__base_exception_t {
-        struct __cfaehm__base_exception_t_vtable const * virtual_table;
-};
-extern struct __cfaehm__base_exception_t_vtable
-        ___cfaehm__base_exception_t_vtable_instance;
 // Used in throw statement translation.
 …
     int (*match_block)(exception * except));
-// Clean-up the exception in catch blocks.
-void __cfaehm__cleanup_terminate(void * except);
 // Data structure creates a list of resume handlers.
 struct __cfaehm__try_resume_node {
 …
 };
-// These act as constructor and destructor for the resume node.
 void __cfaehm__try_resume_setup(
     struct __cfaehm__try_resume_node * node,
 …
 // Check for a standard way to call fake deconstructors.
+struct __cfaehm__cleanup_hook {};
+struct __cfaehm__cleanup_hook {
+};
 #ifdef __CFORALL__
+}
 #endif
+#endif //EXCEPTION_H

src/libcfa/fstream.c

-              r0720e049
+              r3d4b23fa
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Jul 20 15:20:49 2017
 // Update Count     : 252
+// Last Modified On : Thu Jul  6 18:38:25 2017
+// Update Count     : 251
 //
 #include "fstream"
+extern "C" {
 #include <stdio.h>                                                                              // vfprintf, vfscanf
 #include <stdlib.h>                                                                             // exit
 …
 #include <float.h>                                                                              // DBL_DIG, LDBL_DIG
 #include <complex.h>                                                                    // creal, cimag
+#include <assert.h>
+}
+#include "assert"
 #define IO_MSG "I/O error: "

src/libcfa/interpose.c

-              r0720e049
+              r3d4b23fa
+//                              -*- Mode: CFA -*-
 //
 // Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo
 …
 // Author           : Thierry Delisle
 // Created On       : Wed Mar 29 16:10:31 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Jul 21 22:27:33 2017
 // Update Count     : 1
+// Last Modified By :
+// Last Modified On :
+// Update Count     : 0
 //
 …
+        }
+}
-// Local Variables: //
-// mode: c //
-// tab-width: 4 //
-// End: //

src/libcfa/interpose.h

-              r0720e049
+              r3d4b23fa
+//                              -*- Mode: CFA -*-
 //
 // Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo
 …
 // Author           : Thierry Delisle
 // Created On       : Wed Mar 29 15:56:41 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Jul 21 22:33:02 2017
 // Update Count     : 2
+// Last Modified By :
+// Last Modified On :
+// Update Count     : 0
 //
+#pragma once
+#ifndef INTERPOSE_H
+#define INTERPOSE_H
 void * interpose_symbol( const char* symbol, , const char *version );
 …
 extern __typeof__( exit ) libc_abort __attribute__(( noreturn ));
+// Local Variables: //
+// mode: c //
+// tab-width: 4 //
+// End: //
+#endif //INTERPOSE_H

src/libcfa/iostream

-              r0720e049
+              r3d4b23fa
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed Aug  9 16:42:47 2017
 // Update Count     : 131
+// Last Modified On : Fri Jul  7 08:35:59 2017
+// Update Count     : 118
 //
 …
 }; // ostream
+// trait writeable( otype T ) {
+//      forall( dtype ostype | ostream( ostype ) ) ostype * ?|?( ostype *, T );
+// }; // writeable
+trait writeable( otype T, dtype ostype | ostream( ostype ) ) {
+        ostype * ?|?( ostype *, T );
+trait writeable( otype T ) {
+        forall( dtype ostype | ostream( ostype ) ) ostype * ?|?( ostype *, T );
 }; // writeable
 …
 // tuples
+forall( dtype ostype, otype T, ttype Params | writeable( T, ostype ) | { ostype * ?|?( ostype *, Params ); } )
+ostype * ?|?( ostype * os, T arg, Params rest );
+forall( dtype ostype, otype T, ttype Params | ostream( ostype ) | writeable( T ) | { ostype * ?|?( ostype *, Params ); } ) ostype * ?|?( ostype * os, T arg, Params rest );
 // manipulators
 …
 // writes the range [begin, end) to the given stream
 forall( dtype ostype, otype elt_type | writeable( elt_type, ostype ), otype iterator_type | iterator( iterator_type, elt_type ) )
 void write( iterator_type begin, iterator_type end, ostype * os );
+forall( otype elt_type | writeable( elt_type ), otype iterator_type | iterator( iterator_type, elt_type ), dtype os_type | ostream( os_type ) )
+void write( iterator_type begin, iterator_type end, os_type *os );
 forall( dtype ostype, otype elt_type | writeable( elt_type, ostype ), otype iterator_type | iterator( iterator_type, elt_type ) )
 void write_reverse( iterator_type begin, iterator_type end, ostype * os );
+forall( otype elt_type | writeable( elt_type ), otype iterator_type | iterator( iterator_type, elt_type ), dtype os_type | ostream( os_type ) )
+void write_reverse( iterator_type begin, iterator_type end, os_type *os );
 //---------------------------------------

src/libcfa/iostream.c

-              r0720e049
+              r3d4b23fa
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed Aug  9 16:46:51 2017
 // Update Count     : 401
+// Last Modified On : Thu Jul  6 18:14:17 2017
+// Update Count     : 396
 //
 …
 forall( dtype ostype | ostream( ostype ) )
 ostype * ?|?( ostype * os, float _Complex fc ) {
+        if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
+        fmt( os, "%g%+gi", crealf( fc ), cimagf( fc ) );
+        os | crealf( fc );
+        _Bool temp = sepDisable( os );                                          // disable separators within complex value
+        if ( cimagf( fc ) >= 0 ) os | '+';                                      // negative value prints '-'
+        os | cimagf( fc ) | 'i';
+        sepReset( os, temp );                                                           // reset separator
         return os;
 } // ?|?
 …
 forall( dtype ostype | ostream( ostype ) )
 ostype * ?|?( ostype * os, double _Complex dc ) {
+        if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
+        fmt( os, "%.*lg%+.*lgi", DBL_DIG, creal( dc ), DBL_DIG, cimag( dc ) );
+        os | creal( dc );
+        _Bool temp = sepDisable( os );                                          // disable separators within complex value
+        if ( cimag( dc ) >= 0 ) os | '+';                                       // negative value prints '-'
+        os | cimag( dc ) | 'i';
+        sepReset( os, temp );                                                           // reset separator
         return os;
 } // ?|?
 …
 forall( dtype ostype | ostream( ostype ) )
 ostype * ?|?( ostype * os, long double _Complex ldc ) {
+        if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
+        fmt( os, "%.*Lg%+.*Lgi", LDBL_DIG, creall( ldc ), LDBL_DIG, cimagl( ldc ) );
+        os | creall( ldc );
+        _Bool temp = sepDisable( os );                                          // disable separators within complex value
+        if ( cimagl( ldc ) >= 0 ) os | '+';                                     // negative value prints '-'
+        os | cimagl( ldc ) | 'i';
+        sepReset( os, temp );                                                           // reset separator
         return os;
 } // ?|?
 …
 // tuples
 forall( dtype ostype, otype T, ttype Params | writeable( T, ostype ) | { ostype * ?|?( ostype *, Params ); } )
+forall( dtype ostype, otype T, ttype Params | ostream( ostype ) | writeable( T ) | { ostype * ?|?( ostype *, Params ); } )
 ostype * ?|?( ostype * os, T arg, Params rest ) {
         os | arg;                                                                                       // print first argument
 …
 //---------------------------------------
 forall( dtype ostype, otype elt_type | writeable( elt_type, ostype ), otype iterator_type | iterator( iterator_type, elt_type ) )
 void write( iterator_type begin, iterator_type end, ostype * os ) {
         void print( elt_type i ) { os | i; }
+forall( otype elttype | writeable( elttype ), otype iteratortype | iterator( iteratortype, elttype ), dtype ostype | ostream( ostype ) )
+void write( iteratortype begin, iteratortype end, ostype * os ) {
+        void print( elttype i ) { os | i; }
         for_each( begin, end, print );
 } // ?|?
 forall( dtype ostype, otype elt_type | writeable( elt_type, ostype ), otype iterator_type | iterator( iterator_type, elt_type ) )
 void write_reverse( iterator_type begin, iterator_type end, ostype * os ) {
         void print( elt_type i ) { os | i; }
+forall( otype elttype | writeable( elttype ), otype iteratortype | iterator( iteratortype, elttype ), dtype ostype | ostream( ostype ) )
+void write_reverse( iteratortype begin, iteratortype end, ostype * os ) {
+        void print( elttype i ) { os | i; }
         for_each_reverse( begin, end, print );
 } // ?|?

src/libcfa/libhdr.h

-              r0720e049
+              r3d4b23fa
 // Author           : Thierry Delisle
 // Created On       : Mon Nov 28 12:27:26 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 09:56:32 2017
 // Update Count     : 1
+// Last Modified By : Thierry Delisle
+// Last Modified On : Mon Nov 28 12:27:26 2016
+// Update Count     : 0
 //
+#pragma once
+#ifndef __LIB_HDR_H__
+#define __LIB_HDR_H__
 #include "libalign.h"
 …
 #include "libtools.h"
+#endif //__LIB_HDR_H__
 // Local Variables: //
 // mode: c //

src/libcfa/libhdr/libalign.h

-              r0720e049
+              r3d4b23fa
+//                              -*- Mode: C++ -*-
 //
 // Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo
 …
 // Author           : Thierry Delisle
 // Created On       : Mon Nov 28 12:27:26 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Jul 21 23:05:35 2017
 // Update Count     : 2
+// Last Modified By : Thierry Delisle
+// Last Modified On : Mon Nov 28 12:27:26 2016
+// Update Count     : 0
 //
 // This  library is free  software; you  can redistribute  it and/or  modify it
 …
 //
-#pragma once
+#include <assert.h>
+#ifndef __LIB_ALIGN_H__
+#define __LIB_ALIGN_H__
+#include "assert"
 #include <stdbool.h>
 …
 } // uCeiling
+#endif // __LIB_ALIGN_H__
 // Local Variables: //
 // compile-command: "make install" //

src/libcfa/libhdr/libdebug.h

-              r0720e049
+              r3d4b23fa
 // Author           : Thierry Delisle
 // Created On       : Mon Nov 28 12:27:26 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 10:02:24 2017
 // Update Count     : 1
+// Last Modified By : Thierry Delisle
+// Last Modified On : Mon Nov 28 12:27:26 2016
+// Update Count     : 0
 //
+#pragma once
+#ifndef __LIB_DEBUG_H__
+#define __LIB_DEBUG_H__
 #ifdef __CFA_DEBUG__
 …
 #endif
+#endif //__LIB_DEBUG_H__
 // Local Variables: //
 // mode: c //

src/libcfa/libhdr/libtools.h

-              r0720e049
+              r3d4b23fa
 // Author           : Thierry Delisle
 // Created On       : Mon Nov 28 12:27:26 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 10:02:10 2017
 // Update Count     : 1
+// Last Modified By : Thierry Delisle
+// Last Modified On : Mon Nov 28 12:27:26 2016
+// Update Count     : 0
 //
+#pragma once
+#ifndef __LIB_TOOLS_H__
+#define __LIB_TOOLS_H__
 // void abortf( const char *fmt, ... ) {
 …
 #endif
+#endif //__LIB_TOOLS_H__
 // Local Variables: //
 // mode: c //

src/libcfa/math

-              r0720e049
+              r3d4b23fa
 // Created On       : Mon Apr 18 23:37:04 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Mon Aug  7 07:51:15 2017
 // Update Count     : 108
+// Last Modified On : Fri Jul  7 09:34:15 2017
+// Update Count     : 61
 //
 #pragma once
+#include <math.h>
+#include <complex.h>
+//---------------------- General ----------------------
+static inline float ?%?( float x, float y ) { return fmodf( x, y ); }
+static inline float fmod( float x, float y ) { return fmodf( x, y ); }
+static inline double ?%?( double x, double y ) { return fmod( x, y ); }
+extern "C" {
+#include <math.h>                                                                               // fpclassify, isfinite, isnormal, isnan, isinf
+} // extern "C"
+float ?%?( float, float );
+float fmod( float, float );
+double ?%?( double, double );
 // extern "C" { double fmod( double, double ); }
+static inline long double ?%?( long double x, long double y ) { return fmodl( x, y ); }
+static inline long double fmod( long double x, long double y ) { return fmodl( x, y ); }
+static inline float remainder( float x, float y ) { return remainderf( x, y ); }
+long double ?%?( long double, long double );
+long double fmod( long double, long double );
+float remainder( float, float );
 // extern "C" { double remainder( double, double ); }
+static inline long double remainder( long double x, long double y ) { return remainderl( x, y ); }
+static inline float remquo( float x, float y, int * quo ) { return remquof( x, y, quo ); }
+// extern "C" { double remquo( double x, double y, int * quo ); }
+static inline long double remquo( long double x, long double y, int * quo ) { return remquol( x, y, quo ); }
+static inline [ int, float ] remquo( float x, float y ) { int quo; x = remquof( x, y, &quo ); return [ quo, x ]; }
+static inline [ int, double ] remquo( double x, double y ) { int quo; x = remquo( x, y, &quo ); return [ quo, x ]; }
+static inline [ int, long double ] remquo( long double x, long double y ) { int quo; x = remquol( x, y, &quo ); return [ quo, x ]; }
+static inline [ float, float ] div( float x, float y ) { y = modff( x / y, &x ); return [ x, y ]; }
+static inline [ double, double ] div( double x, double y ) { y = modf( x / y, &x ); return [ x, y ]; }
+static inline [ long double, long double ] div( long double x, long double y ) { y = modfl( x / y, &x ); return [ x, y ]; }
+static inline float fma( float x, float y, float z ) { return fmaf( x, y, z ); }
+long double remainder( long double, long double );
+[ int, float ] remquo( float, float );
+float remquo( float, float, int * );
+[ int, double ] remquo( double, double );
+// extern "C" { double remquo( double, double, int * ); }
+[ int, long double ] remquo( long double, long double );
+long double remquo( long double, long double, int * );
+[ int, float ] div( float, float );                                             // alternative name for remquo
+float div( float, float, int * );
+[ int, double ] div( double, double );
+// extern "C" { double div( double, double, int * ); }
+[ int, long double ] div( long double, long double );
+long double div( long double, long double, int * );
+float fma( float, float, float );
 // extern "C" { double fma( double, double, double ); }
+static inline long double fma( long double x, long double y, long double z ) { return fmal( x, y, z ); }
+static inline float fdim( float x, float y ) { return fdimf( x, y ); }
+long double fma( long double, long double, long double );
+float fdim( float, float );
 // extern "C" { double fdim( double, double ); }
+static inline long double fdim( long double x, long double y ) { return fdiml( x, y ); }
+static inline float nan( const char * tag ) { return nanf( tag ); }
+long double fdim( long double, long double );
+float nan( const char * );
 // extern "C" { double nan( const char * ); }
+static inline long double nan( const char * tag ) { return nanl( tag ); }
+long double nan( const char * );
 //---------------------- Exponential ----------------------
+static inline float exp( float x ) { return expf( x ); }
+float exp( float );
 // extern "C" { double exp( double ); }
+static inline long double exp( long double x ) { return expl( x ); }
+static inline float _Complex exp( float _Complex x ) { return cexpf( x ); }
+static inline double _Complex exp( double _Complex x ) { return cexp( x ); }
+static inline long double _Complex exp( long double _Complex x ) { return cexpl( x ); }
+static inline float exp2( float x ) { return exp2f( x ); }
+long double exp( long double );
+float _Complex exp( float _Complex );
+double _Complex exp( double _Complex );
+long double _Complex exp( long double _Complex );
+float exp2( float );
 // extern "C" { double exp2( double ); }
+static inline long double exp2( long double x ) { return exp2l( x ); }
 //static inline float _Complex exp2( float _Complex x ) { return cexp2f( x ); }
 //static inline double _Complex exp2( double _Complex x ) { return cexp2( x ); }
 //static inline long double _Complex exp2( long double _Complex x ) { return cexp2l( x ); }
+static inline float expm1( float x ) { return expm1f( x ); }
+long double exp2( long double );
+// float _Complex exp2( float _Complex );
+// double _Complex exp2( double _Complex );
+// long double _Complex exp2( long double _Complex );
+float expm1( float );
 // extern "C" { double expm1( double ); }
+static inline long double expm1( long double x ) { return expm1l( x ); }
+static inline float pow( float x, float y ) { return powf( x, y ); }
+long double expm1( long double );
+float log( float );
+// extern "C" { double log( double ); }
+long double log( long double );
+float _Complex log( float _Complex );
+double _Complex log( double _Complex );
+long double _Complex log( long double _Complex );
+float log2( float );
+// extern "C" { double log2( double ); }
+long double log2( long double );
+// float _Complex log2( float _Complex );
+// double _Complex log2( double _Complex );
+// long double _Complex log2( long double _Complex );
+float log10( float );
+// extern "C" { double log10( double ); }
+long double log10( long double );
+// float _Complex log10( float _Complex );
+// double _Complex log10( double _Complex );
+// long double _Complex log10( long double _Complex );
+float log1p( float );
+// extern "C" { double log1p( double ); }
+long double log1p( long double );
+int ilogb( float );
+// extern "C" { int ilogb( double ); }
+int ilogb( long double );
+float logb( float );
+// extern "C" { double logb( double ); }
+long double logb( long double );
+//---------------------- Power ----------------------
+float sqrt( float );
+// extern "C" { double sqrt( double ); }
+long double sqrt( long double );
+float _Complex sqrt( float _Complex );
+double _Complex sqrt( double _Complex );
+long double _Complex sqrt( long double _Complex );
+float cbrt( float );
+// extern "C" { double cbrt( double ); }
+long double cbrt( long double );
+float hypot( float, float );
+// extern "C" { double hypot( double, double ); }
+long double hypot( long double, long double );
+float pow( float, float );
 // extern "C" { double pow( double, double ); }
+static inline long double pow( long double x, long double y ) { return powl( x, y ); }
+static inline float _Complex pow( float _Complex x, float _Complex y ) { return cpowf( x, y ); }
+static inline double _Complex pow( double _Complex x, double _Complex y ) { return cpow( x, y ); }
+static inline long double _Complex pow( long double _Complex x, long double _Complex y ) { return cpowl( x, y ); }
+//---------------------- Logarithm ----------------------
+static inline float log( float x ) { return logf( x ); }
+// extern "C" { double log( double ); }
+static inline long double log( long double x ) { return logl( x ); }
+static inline float _Complex log( float _Complex x ) { return clogf( x ); }
+static inline double _Complex log( double _Complex x ) { return clog( x ); }
+static inline long double _Complex log( long double _Complex x ) { return clogl( x ); }
+static inline float log2( float x ) { return log2f( x ); }
+// extern "C" { double log2( double ); }
+static inline long double log2( long double x ) { return log2l( x ); }
+// static inline float _Complex log2( float _Complex x ) { return clog2f( x ); }
+// static inline double _Complex log2( double _Complex x ) { return clog2( x ); }
+// static inline long double _Complex log2( long double _Complex x ) { return clog2l( x ); }
+static inline float log10( float x ) { return log10f( x ); }
+// extern "C" { double log10( double ); }
+static inline long double log10( long double x ) { return log10l( x ); }
+// static inline float _Complex log10( float _Complex x ) { return clog10f( x ); }
+// static inline double _Complex log10( double _Complex x ) { return clog10( x ); }
+// static inline long double _Complex log10( long double _Complex x ) { return clog10l( x ); }
+static inline float log1p( float x ) { return log1pf( x ); }
+// extern "C" { double log1p( double ); }
+static inline long double log1p( long double x ) { return log1pl( x ); }
+static inline int ilogb( float x ) { return ilogbf( x ); }
+// extern "C" { int ilogb( double ); }
+static inline int ilogb( long double x ) { return ilogbl( x ); }
+static inline float logb( float x ) { return logbf( x ); }
+// extern "C" { double logb( double ); }
+static inline long double logb( long double x ) { return logbl( x ); }
+static inline float sqrt( float x ) { return sqrtf( x ); }
+// extern "C" { double sqrt( double ); }
+static inline long double sqrt( long double x ) { return sqrtl( x ); }
+static inline float _Complex sqrt( float _Complex x ) { return csqrtf( x ); }
+static inline double _Complex sqrt( double _Complex x ) { return csqrt( x ); }
+static inline long double _Complex sqrt( long double _Complex x ) { return csqrtl( x ); }
+static inline float cbrt( float x ) { return cbrtf( x ); }
+// extern "C" { double cbrt( double ); }
+static inline long double cbrt( long double x ) { return cbrtl( x ); }
+static inline float hypot( float x, float y ) { return hypotf( x, y ); }
+// extern "C" { double hypot( double, double ); }
+static inline long double hypot( long double x, long double y ) { return hypotl( x, y ); }
+long double pow( long double, long double );
+float _Complex pow( float _Complex, float _Complex );
+double _Complex pow( double _Complex, double _Complex );
+long double _Complex pow( long double _Complex, long double _Complex );
 //---------------------- Trigonometric ----------------------
+static inline float sin( float x ) { return sinf( x ); }
+float sin( float );
 // extern "C" { double sin( double ); }
+static inline long double sin( long double x ) { return sinl( x ); }
+static inline float _Complex sin( float _Complex x ) { return csinf( x ); }
+static inline double _Complex sin( double _Complex x ) { return csin( x ); }
+static inline long double _Complex sin( long double _Complex x ) { return csinl( x ); }
+static inline float cos( float x ) { return cosf( x ); }
+long double sin( long double );
+float _Complex sin( float _Complex );
+double _Complex sin( double _Complex );
+long double _Complex sin( long double _Complex );
+float cos( float );
 // extern "C" { double cos( double ); }
+static inline long double cos( long double x ) { return cosl( x ); }
+static inline float _Complex cos( float _Complex x ) { return ccosf( x ); }
+static inline double _Complex cos( double _Complex x ) { return ccos( x ); }
+static inline long double _Complex cos( long double _Complex x ) { return ccosl( x ); }
+static inline float tan( float x ) { return tanf( x ); }
+long double cos( long double );
+float _Complex cos( float _Complex );
+double _Complex cos( double _Complex );
+long double _Complex cos( long double _Complex );
+float tan( float );
 // extern "C" { double tan( double ); }
+static inline long double tan( long double x ) { return tanl( x ); }
+static inline float _Complex tan( float _Complex x ) { return ctanf( x ); }
+static inline double _Complex tan( double _Complex x ) { return ctan( x ); }
+static inline long double _Complex tan( long double _Complex x ) { return ctanl( x ); }
+static inline float asin( float x ) { return asinf( x ); }
+long double tan( long double );
+float _Complex tan( float _Complex );
+double _Complex tan( double _Complex );
+long double _Complex tan( long double _Complex );
+float asin( float );
 // extern "C" { double asin( double ); }
+static inline long double asin( long double x ) { return asinl( x ); }
+static inline float _Complex asin( float _Complex x ) { return casinf( x ); }
+static inline double _Complex asin( double _Complex x ) { return casin( x ); }
+static inline long double _Complex asin( long double _Complex x ) { return casinl( x ); }
+static inline float acos( float x ) { return acosf( x ); }
+long double asin( long double );
+float _Complex asin( float _Complex );
+double _Complex asin( double _Complex );
+long double _Complex asin( long double _Complex );
+float acos( float );
 // extern "C" { double acos( double ); }
+static inline long double acos( long double x ) { return acosl( x ); }
+static inline float _Complex acos( float _Complex x ) { return cacosf( x ); }
+static inline double _Complex acos( double _Complex x ) { return cacos( x ); }
+static inline long double _Complex acos( long double _Complex x ) { return cacosl( x ); }
+static inline float atan( float x ) { return atanf( x ); }
+long double acos( long double );
+float _Complex acos( float _Complex );
+double _Complex acos( double _Complex );
+long double _Complex acos( long double _Complex );
+float atan( float );
 // extern "C" { double atan( double ); }
+static inline long double atan( long double x ) { return atanl( x ); }
+static inline float _Complex atan( float _Complex x ) { return catanf( x ); }
+static inline double _Complex atan( double _Complex x ) { return catan( x ); }
+static inline long double _Complex atan( long double _Complex x ) { return catanl( x ); }
+static inline float atan2( float x, float y ) { return atan2f( x, y ); }
+long double atan( long double );
+float _Complex atan( float _Complex );
+double _Complex atan( double _Complex );
+long double _Complex atan( long double _Complex );
+float atan2( float, float );
 // extern "C" { double atan2( double, double ); }
+static inline long double atan2( long double x, long double y ) { return atan2l( x, y ); }
+// alternative name for atan2
+static inline float atan( float x, float y ) { return atan2f( x, y ); }
+static inline double atan( double x, double y ) { return atan2( x, y ); }
+static inline long double atan( long double x, long double y ) { return atan2l( x, y ); }
+long double atan2( long double, long double );
+float atan( float, float );                                                             // alternative name for atan2
+double atan( double, double );
+long double atan( long double, long double );
 //---------------------- Hyperbolic ----------------------
+static inline float sinh( float x ) { return sinhf( x ); }
+float sinh( float );
 // extern "C" { double sinh( double ); }
+static inline long double sinh( long double x ) { return sinhl( x ); }
+static inline float _Complex sinh( float _Complex x ) { return csinhf( x ); }
+static inline double _Complex sinh( double _Complex x ) { return csinh( x ); }
+static inline long double _Complex sinh( long double _Complex x ) { return csinhl( x ); }
+static inline float cosh( float x ) { return coshf( x ); }
+long double sinh( long double );
+float _Complex sinh( float _Complex );
+double _Complex sinh( double _Complex );
+long double _Complex sinh( long double _Complex );
+float cosh( float );
 // extern "C" { double cosh( double ); }
+static inline long double cosh( long double x ) { return coshl( x ); }
+static inline float _Complex cosh( float _Complex x ) { return ccoshf( x ); }
+static inline double _Complex cosh( double _Complex x ) { return ccosh( x ); }
+static inline long double _Complex cosh( long double _Complex x ) { return ccoshl( x ); }
+static inline float tanh( float x ) { return tanhf( x ); }
+long double cosh( long double );
+float _Complex cosh( float _Complex );
+double _Complex cosh( double _Complex );
+long double _Complex cosh( long double _Complex );
+float tanh( float );
 // extern "C" { double tanh( double ); }
+static inline long double tanh( long double x ) { return tanhl( x ); }
+static inline float _Complex tanh( float _Complex x ) { return ctanhf( x ); }
+static inline double _Complex tanh( double _Complex x ) { return ctanh( x ); }
+static inline long double _Complex tanh( long double _Complex x ) { return ctanhl( x ); }
+static inline float asinh( float x ) { return asinhf( x ); }
+long double tanh( long double );
+float _Complex tanh( float _Complex );
+double _Complex tanh( double _Complex );
+long double _Complex tanh( long double _Complex );
+float asinh( float );
 // extern "C" { double asinh( double ); }
+static inline long double asinh( long double x ) { return asinhl( x ); }
+static inline float _Complex asinh( float _Complex x ) { return casinhf( x ); }
+static inline double _Complex asinh( double _Complex x ) { return casinh( x ); }
+static inline long double _Complex asinh( long double _Complex x ) { return casinhl( x ); }
+static inline float acosh( float x ) { return acoshf( x ); }
+long double asinh( long double );
+float _Complex asinh( float _Complex );
+double _Complex asinh( double _Complex );
+long double _Complex asinh( long double _Complex );
+float acosh( float );
 // extern "C" { double acosh( double ); }
+static inline long double acosh( long double x ) { return acoshl( x ); }
+static inline float _Complex acosh( float _Complex x ) { return cacoshf( x ); }
+static inline double _Complex acosh( double _Complex x ) { return cacosh( x ); }
+static inline long double _Complex acosh( long double _Complex x ) { return cacoshl( x ); }
+static inline float atanh( float x ) { return atanhf( x ); }
+long double acosh( long double );
+float _Complex acosh( float _Complex );
+double _Complex acosh( double _Complex );
+long double _Complex acosh( long double _Complex );
+float atanh( float );
 // extern "C" { double atanh( double ); }
+static inline long double atanh( long double x ) { return atanhl( x ); }
+static inline float _Complex atanh( float _Complex x ) { return catanhf( x ); }
+static inline double _Complex atanh( double _Complex x ) { return catanh( x ); }
+static inline long double _Complex atanh( long double _Complex x ) { return catanhl( x ); }
+long double atanh( long double );
+float _Complex atanh( float _Complex );
+double _Complex atanh( double _Complex );
+long double _Complex atanh( long double _Complex );
 //---------------------- Error / Gamma ----------------------
+static inline float erf( float x ) { return erff( x ); }
+float erf( float );
 // extern "C" { double erf( double ); }
+static inline long double erf( long double x ) { return erfl( x ); }
+long double erf( long double );
 // float _Complex erf( float _Complex );
 // double _Complex erf( double _Complex );
 // long double _Complex erf( long double _Complex );
+static inline float erfc( float x ) { return erfcf( x ); }
+float erfc( float );
 // extern "C" { double erfc( double ); }
+static inline long double erfc( long double x ) { return erfcl( x ); }
+long double erfc( long double );
 // float _Complex erfc( float _Complex );
 // double _Complex erfc( double _Complex );
 // long double _Complex erfc( long double _Complex );
+static inline float lgamma( float x ) { return lgammaf( x ); }
+float lgamma( float );
 // extern "C" { double lgamma( double ); }
+static inline long double lgamma( long double x ) { return lgammal( x ); }
+static inline float lgamma( float x, int * sign ) { return lgammaf_r( x, sign ); }
+static inline double lgamma( double x, int * sign ) { return lgamma_r( x, sign ); }
+static inline long double lgamma( long double x, int * sign ) { return lgammal_r( x, sign ); }
+static inline float tgamma( float x ) { return tgammaf( x ); }
+long double lgamma( long double );
+float lgamma( float, int * );
+double lgamma( double, int * );
+long double lgamma( long double, int * );
+float tgamma( float );
 // extern "C" { double tgamma( double ); }
+static inline long double tgamma( long double x ) { return tgammal( x ); }
+long double tgamma( long double );
 //---------------------- Nearest Integer ----------------------
+static inline float floor( float x ) { return floorf( x ); }
+float floor( float );
 // extern "C" { double floor( double ); }
+static inline long double floor( long double x ) { return floorl( x ); }
+static inline float ceil( float x ) { return ceilf( x ); }
+long double floor( long double );
+float ceil( float );
 // extern "C" { double ceil( double ); }
+static inline long double ceil( long double x ) { return ceill( x ); }
+static inline float trunc( float x ) { return truncf( x ); }
+long double ceil( long double );
+float trunc( float );
 // extern "C" { double trunc( double ); }
+static inline long double trunc( long double x ) { return truncl( x ); }
+static inline float rint( float x ) { return rintf( x ); }
+// extern "C" { double rint( double x ); }
+static inline long double rint( long double x ) { return rintl( x ); }
+static inline long int rint( float x ) { return lrintf( x ); }
+static inline long int rint( double x ) { return lrint( x ); }
+static inline long int rint( long double x ) { return lrintl( x ); }
+static inline long long int rint( float x ) { return llrintf( x ); }
+static inline long long int rint( double x ) { return llrint( x ); }
+static inline long long int rint( long double x ) { return llrintl( x ); }
+static inline long int lrint( float x ) { return lrintf( x ); }
+long double trunc( long double );
+float rint( float );
+long double rint( long double );
+long int rint( float );
+long int rint( double );
+long int rint( long double );
+long long int rint( float );
+long long int rint( double );
+long long int rint( long double );
+long int lrint( float );
 // extern "C" { long int lrint( double ); }
+static inline long int lrint( long double x ) { return lrintl( x ); }
+static inline long long int llrint( float x ) { return llrintf( x ); }
+long int lrint( long double );
+long long int llrint( float );
 // extern "C" { long long int llrint( double ); }
+static inline long long int llrint( long double x ) { return llrintl( x ); }
+static inline float nearbyint( float x ) { return nearbyintf( x ); }
+long long int llrint( long double );
+float nearbyint( float );
 // extern "C" { double nearbyint( double ); }
+static inline long double nearbyint( long double x ) { return nearbyintl( x ); }
+static inline float round( float x ) { return roundf( x ); }
+// extern "C" { double round( double x ); }
+static inline long double round( long double x ) { return roundl( x ); }
+static inline long int round( float x ) { return lroundf( x ); }
+static inline long int round( double x ) { return lround( x ); }
+static inline long int round( long double x ) { return lroundl( x ); }
+static inline long long int round( float x ) { return llroundf( x ); }
+static inline long long int round( double x ) { return llround( x ); }
+static inline long long int round( long double x ) { return llroundl( x ); }
+static inline long int lround( float x ) { return lroundf( x ); }
+long double nearbyint( long double );
+float round( float );
+long double round( long double );
+long int round( float );
+long int round( double );
+long int round( long double );
+long long int round( float );
+long long int round( double );
+long long int round( long double );
+long int lround( float );
 // extern "C" { long int lround( double ); }
+static inline long int lround( long double x ) { return lroundl( x ); }
+static inline long long int llround( float x ) { return llroundf( x ); }
+long int lround( long double );
+long long int llround( float );
 // extern "C" { long long int llround( double ); }
+static inline long long int llround( long double x ) { return llroundl( x ); }
+long long int llround( long double );
 //---------------------- Manipulation ----------------------
+static inline float copysign( float x, float y ) { return copysignf( x, y ); }
+float copysign( float, float );
 // extern "C" { double copysign( double, double ); }
+static inline long double copysign( long double x, long double y ) { return copysignl( x, y ); }
+static inline float frexp( float x, int * ip ) { return frexpf( x, ip ); }
+long double copysign( long double, long double );
+float frexp( float, int * );
 // extern "C" { double frexp( double, int * ); }
+static inline long double frexp( long double x, int * ip ) { return frexpl( x, ip ); }
+static inline float ldexp( float x, int exp2 ) { return ldexpf( x, exp2 ); }
+long double frexp( long double, int * );
+float ldexp( float, int );
 // extern "C" { double ldexp( double, int ); }
+static inline long double ldexp( long double x, int exp2 ) { return ldexpl( x, exp2 ); }
+static inline [ float, float ] modf( float x ) { float i; x = modff( x, &i ); return [ i, x ]; }
+static inline float modf( float x, float * i ) { return modff( x, i ); }
+static inline [ double, double ] modf( double x ) { double i; x = modf( x, &i ); return [ i, x ]; }
+long double ldexp( long double, int );
+[ float, float ] modf( float );
+float modf( float, float * );
+[ double, double ] modf( double );
 // extern "C" { double modf( double, double * ); }
+static inline [ long double, long double ] modf( long double x ) { long double i; x = modfl( x, &i ); return [ i, x ]; }
+static inline long double modf( long double x, long double * i ) { return modfl( x, i ); }
+static inline float nextafter( float x, float y ) { return nextafterf( x, y ); }
+[ long double, long double ] modf( long double );
+long double modf( long double, long double * );
+float nextafter( float, float );
 // extern "C" { double nextafter( double, double ); }
+static inline long double nextafter( long double x, long double y ) { return nextafterl( x, y ); }
+static inline float nexttoward( float x, long double y ) { return nexttowardf( x, y ); }
+long double nextafter( long double, long double );
+float nexttoward( float, long double );
 // extern "C" { double nexttoward( double, long double ); }
+static inline long double nexttoward( long double x, long double y ) { return nexttowardl( x, y ); }
+static inline float scalbn( float x, int exp ) { return scalbnf( x, exp ); }
+long double nexttoward( long double, long double );
+float scalbn( float, int );
 // extern "C" { double scalbn( double, int ); }
+static inline long double scalbn( long double x, int exp ) { return scalbnl( x, exp ); }
+static inline float scalbn( float x, long int exp ) { return scalblnf( x, exp ); }
+static inline double scalbn( double x, long int exp ) { return scalbln( x, exp ); }
+static inline long double scalbn( long double x, long int exp ) { return scalblnl( x, exp ); }
+static inline float scalbln( float x, long int exp ) { return scalblnf( x, exp ); }
+long double scalbn( long double, int );
+float scalbln( float, long int );
 // extern "C" { double scalbln( double, long int ); }
+static inline long double scalbln( long double x, long int exp ) { return scalblnl( x, exp ); }
+long double scalbln( long double, long int );
 // Local Variables: //

src/libcfa/startup.h

-              r0720e049
+              r3d4b23fa
+//                              -*- Mode: CFA -*-
 //
 // Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo
 …
 // Author           : Thierry Delisle
 // Created On       : Wed Mar 29 15:56:41 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Jul 20 21:37:11 2017
 // Update Count     : 2
+// Last Modified By :
+// Last Modified On :
+// Update Count     : 0
 //
+#pragma once
+#ifndef STARTUP_H
+#define STARTUP_H
 #if GCC_VERSION > 50000
 …
 #endif
+// Local Variables: //
+// mode: c //
+// tab-width: 4 //
+// End: //
+#endif //STARTUP_H

src/libcfa/stdhdr/assert.h

-              r0720e049
+              r3d4b23fa
 // Created On       : Mon Jul  4 23:25:26 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Mon Jul 31 23:09:32 2017
 // Update Count     : 13
+// Last Modified On : Tue Jul  5 20:34:23 2016
+// Update Count     : 8
 //
 …
 #endif //__CFORALL__
+// has internal check for multiple expansion
 #include_next <assert.h>
-#ifdef NDEBUG
-        #define assertf( expr, fmt, ... ) ((void)0)
-#else
-        #define __STRINGIFY__(str) #str
-        #define __VSTRINGIFY__(str) __STRINGIFY__(str)
-        #define assertf( expr, fmt, ... ) ((expr) ? ((void)0) : __assert_fail_f(__VSTRINGIFY__(expr), __FILE__, __LINE__, __PRETTY_FUNCTION__, fmt, ## __VA_ARGS__ ))
-        void __assert_fail_f( const char *assertion, const char *file, unsigned int line, const char *function, const char *fmt, ... ) __attribute__((noreturn, format( printf, 5, 6) ));
-#endif
 #ifdef __CFORALL__

src/libcfa/stdhdr/gmp.h

-              r0720e049
+              r3d4b23fa
+//                               -*- Mode: C -*-
 //
 // Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo
 …
 // Created On       : Sun May 14 23:46:01 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Jul 20 18:10:52 2017
 // Update Count     : 4
+// Last Modified On : Sun May 14 23:46:34 2017
+// Update Count     : 1
 //

src/libcfa/stdlib

-              r0720e049
+              r3d4b23fa
 // Created On       : Thu Jan 28 17:12:35 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Mon Aug  7 11:19:07 2017
 // Update Count     : 223
+// Last Modified On : Fri Jul  7 09:34:49 2017
+// Update Count     : 219
 //
 …
 //---------------------------------------
+extern "C" {
 #ifndef EXIT_FAILURE
 #define EXIT_FAILURE    1                                                               // failing exit status
 #define EXIT_SUCCESS    0                                                               // successful exit status
 #endif // ! EXIT_FAILURE
+} // extern "C"
 //---------------------------------------
 …
 //---------------------------------------
-[ int, int ] div( int num, int denom );
-[ long int, long int ] div( long int num, long int denom );
-[ long long int, long long int ] div( long long int num, long long int denom );
 forall( otype T | { T ?/?( T, T ); T ?%?( T, T ); } )
 [ T, T ] div( T num, T demon );
+[ T, T ] div( T t1, T t2 );
 //---------------------------------------

src/libcfa/stdlib.c

-              r0720e049
+              r3d4b23fa
 // Created On       : Thu Jan 28 17:10:29 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Tue Aug  8 17:31:13 2017
 // Update Count     : 291
+// Last Modified On : Thu Jun  1 21:52:57 2017
+// Update Count     : 280
 //
 …
 //---------------------------------------
+extern "C" {
 #define _XOPEN_SOURCE 600                                                               // posix_memalign, *rand48
 #include <stdlib.h>                                                                             // malloc, free, calloc, realloc, memalign, posix_memalign, bsearch
 …
 #include <math.h>                                                                               // fabsf, fabs, fabsl
 #include <complex.h>                                                                    // _Complex_I
+} // extern "C"
 // resize, non-array types
 …
 //---------------------------------------
-[ int, int ] div( int num, int denom ) { div_t qr = div( num, denom ); return [ qr.quot, qr.rem ]; }
-[ long int, long int ] div( long int num, long int denom ) { ldiv_t qr = ldiv( num, denom ); return [ qr.quot, qr.rem ]; }
-[ long long int, long long int ] div( long long int num, long long int denom ) { lldiv_t qr = lldiv( num, denom ); return [ qr.quot, qr.rem ]; }
 forall( otype T | { T ?/?( T, T ); T ?%?( T, T ); } )
 [ T, T ] div( T num, T denom ) { return [ num / denom, num % denom ]; }
+[ T, T ] div( T t1, T t2 ) { return [ t1 / t2, t1 % t2 ]; }
 //---------------------------------------

src/main.cc

-              r0720e049
+              r3d4b23fa
 // Created On       : Fri May 15 23:12:02 2015
 // Last Modified By : Andrew Beach
 // Last Modified On : Wed Jul 26 14:38:00 2017
 // Update Count     : 443
+// Last Modified On : Fri Jul  7 11:13:00 2017
+// Update Count     : 442
 //
 …
 #include "SynTree/Visitor.h"                // for acceptAll
 #include "Tuples/Tuples.h"                  // for expandMemberTuples, expan...
-#include "Virtual/ExpandCasts.h"            // for expandCasts
 using namespace std;
 …
+                }
-                OPTPRINT( "virtual expandCasts" ) // Must come after translateEHM
-                Virtual::expandCasts( translationUnit );
                 OPTPRINT("instantiateGenerics")
                 GenPoly::instantiateGeneric( translationUnit );

src/prelude/builtins.c

-              r0720e049
+              r3d4b23fa
-//
-// Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo
-//
-// The contents of this file are covered under the licence agreement in the
-// file "LICENCE" distributed with Cforall.
-//
-// builtins.c --
-//
-// Author           : Peter A. Buhr
-// Created On       : Fri Jul 21 16:21:03 2017
-// Last Modified By : Andrew Beach
-// Last Modified On : Tus Jul 25 15:33:00 2017
-// Update Count     : 14
-//
-// exception implementation
 typedef unsigned long long __cfaabi_exception_type_t;
-#include "../libcfa/virtual.h"
 #include "../libcfa/exception.h"
-// exponentiation operator implementation
-extern "C" {
-        float powf( float x, float y );
-        double pow( double x, double y );
-        long double powl( long double x, long double y );
-        float _Complex cpowf( float _Complex x, _Complex float z );
-        double _Complex cpow( double _Complex x, _Complex double z );
-        long double _Complex cpowl( long double _Complex x, _Complex long double z );
-} // extern "C"
-static inline float ?\?( float x, float y ) { return powf( x, y ); }
-static inline double ?\?( double x, double y ) { return pow( x, y ); }
-static inline long double ?\?( long double x, long double y ) { return powl( x, y ); }
-static inline float _Complex ?\?( float _Complex x, _Complex float y ) { return cpowf(x, y ); }
-static inline double _Complex ?\?( double _Complex x, _Complex double y ) { return cpow( x, y ); }
-static inline long double _Complex ?\?( long double _Complex x, _Complex long double y ) { return cpowl( x, y ); }
-static inline long int ?\?( long int ep, unsigned long int y ) { // disallow negative exponent
-        if ( y == 0 ) return 1;                                                         // base case
-    if ( ep == 2 ) return ep << (y - 1);                                // special case, positive shifting only
-    typeof( ep ) op = 1;                                                                // accumulate odd product
-    for ( ; y > 1; y >>= 1 ) {                                                  // squaring exponentiation, O(log2 y)
-                if ( (y & 1) == 1 ) op *= ep;                                   // odd ?
-                ep *= ep;
-        } // for
-    return ep * op;
-} // ?\?
-// FIX ME, cannot resolve the "T op = 1".
-// static inline forall( otype T | { void ?{}( T * this, one_t ); T ?*?( T, T ); } )
-// T ?\?( T ep, unsigned long int y ) {
-//     if ( y == 0 ) return 1;
-//     T op = 1;
-//     for ( ; y > 1; y >>= 1 ) {                                                       // squaring exponentiation, O(log2 y)
-//              if ( (y & 1) == 1 ) op = op * ep;                               // odd ?
-//              ep = ep * ep;
-//     } // for
-//     return ep * op;
-// } // ?\?
-// unsigned computation may be faster and larger
-static inline unsigned long int ?\?( unsigned long int ep, unsigned long int y ) { // disallow negative exponent
-        if ( y == 0 ) return 1;                                                         // base case
-    if ( ep == 2 ) return ep << (y - 1);                                // special case, positive shifting only
-    typeof( ep ) op = 1;                                                                // accumulate odd product
-    for ( ; y > 1; y >>= 1 ) {                                                  // squaring exponentiation, O(log2 y)
-                if ( (y & 1) == 1 ) op *= ep;                                   // odd ?
-                ep *= ep;
-        } // for
-    return ep * op;
-} // ?\?
-static inline double ?\?( long int x, signed long int y ) {     // allow negative exponent
-    if ( y >=  0 ) return (double)(x \ (unsigned long int)y);
-    else return 1.0 / x \ (unsigned int)(-y);
-} // ?\?
-static inline forall( otype T | { void ?{}( T * this, one_t ); T ?*?( T, T ); double ?/?( double, T ); } )
-double ?\?( T x, signed long int y ) {
-    if ( y >=  0 ) return (double)(x \ (unsigned long int)y);
-    else return 1.0 / x \ (unsigned long int)(-y);
-} // ?\?
-static inline long int ?\=?( long int * x, unsigned long int y ) { *x = *x \ y; return *x; }
-static inline unsigned long int ?\=?( unsigned long int * x, unsigned long int y ) { *x = *x \ y; return *x; }
-static inline int ?\=?( int * x, unsigned long int y ) { *x = *x \ y; return *x; }
-static inline unsigned int ?\=?( unsigned int * x, unsigned long int y ) { *x = *x \ y; return *x; }
-// Local Variables: //
-// mode: c //
-// tab-width: 4 //
-// End: //

src/tests/.expect/32/math.txt

-              r0720e049
+              r3d4b23fa
 remainder:-1 -1 -1
 remquo:7 0.0999999 7 0.1 7 0.0999999999999999999
 div:7, 0.2 7, 0.2 7, 0.2
+div:7 0.0999999 7 0.1 7 0.0999999999999999999
 fma:-2 -2 -2
 fdim:2 2 2
 …
 exp2:2 2 2
 expm1:1.71828 1.71828182845905 1.71828182845904524
-pow:1 1 1 0.273957+0.583701i 0.273957253830121+0.583700758758615i 0.273957253830121071+0.583700758758614628i
-256
-256 64 -64 0.015625 -0.015625 18.3791736799526 0.264715-1.1922i
 log:0 0 0 0.346574+0.785398i 0.346573590279973+0.785398163397448i 0.346573590279972655+0.78539816339744831i
 log2:3 3 3
 …
 cbrt:3 3 3
 hypot:1.41421 1.4142135623731 1.41421356237309505
+pow:1 1 1 0.273957+0.583701i 0.273957253830121+0.583700758758615i 0.273957253830121071+0.583700758758614628i
 sin:0.841471 0.841470984807897 0.841470984807896507 1.29846+0.634964i 1.29845758141598+0.634963914784736i 1.29845758141597729+0.634963914784736108i
 cos:0.540302 0.54030230586814 0.540302305868139717 0.83373-0.988898i 0.833730025131149-0.988897705762865i 0.833730025131149049-0.988897705762865096i
 …
 frexp:0.5 3 0.5 3 0.5 3
 ldexp:8 8 8
+modf:2 0.3 2 0.3 2 0.3
+modf:2, 0.3 2, 0.3 2, 0.3
+nextafter:2 2 2
+modf:2 0.3 2 0.3 2 0.3 nextafter:2 2 2
 nexttoward:2 2 2
 scalbn:16 16 16

src/tests/.expect/64/math.txt

-              r0720e049
+              r3d4b23fa
 remainder:-1 -1 -1
 remquo:7 0.0999999 7 0.1 7 0.0999999999999999999
 div:7, 0.2 7, 0.2 7, 0.2
+div:7 0.0999999 7 0.1 7 0.0999999999999999999
 fma:-2 -2 -2
 fdim:2 2 2
 …
 exp2:2 2 2
 expm1:1.71828 1.71828182845905 1.71828182845904524
-pow:1 1 1 0.273957+0.583701i 0.273957253830121+0.583700758758615i 0.273957253830121071+0.583700758758614627i
-256
-256 64 -64 0.015625 -0.015625 18.3791736799526 0.264715-1.1922i
 log:0 0 0 0.346574+0.785398i 0.346573590279973+0.785398163397448i 0.346573590279972655+0.78539816339744831i
 log2:3 3 3
 …
 cbrt:3 3 3
 hypot:1.41421 1.4142135623731 1.41421356237309505
+pow:1 1 1 0.273957+0.583701i 0.273957253830121+0.583700758758615i 0.273957253830121071+0.583700758758614628i
 sin:0.841471 0.841470984807897 0.841470984807896507 1.29846+0.634964i 1.29845758141598+0.634963914784736i 1.29845758141597729+0.634963914784736108i
 cos:0.540302 0.54030230586814 0.540302305868139717 0.83373-0.988898i 0.833730025131149-0.988897705762865i 0.833730025131149049-0.988897705762865096i
 …
 frexp:0.5 3 0.5 3 0.5 3
 ldexp:8 8 8
+modf:2 0.3 2 0.3 2 0.3
+modf:2, 0.3 2, 0.3 2, 0.3
+nextafter:2 2 2
+modf:2 0.3 2 0.3 2 0.3 nextafter:2 2 2
 nexttoward:2 2 2
 scalbn:16 16 16

src/tests/alloc.c

-              r0720e049
+              r3d4b23fa
 // Created On       : Wed Feb  3 07:56:22 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Jul 20 16:01:10 2017
 // Update Count     : 318
+// Last Modified On : Fri Jun  2 15:13:03 2017
+// Update Count     : 316
 //
+#include <assert.h>
+#include <assert>
+extern "C" {
 #include <malloc.h>                                                                             // malloc_usable_size
 #include <stdint.h>                                                                             // uintptr_t
 #include <stdlib.h>                                                                             // posix_memalign
+} // extern
 #include <fstream>
 #include <stdlib>                                                                               // access C malloc, realloc

src/tests/attributes.c

-              r0720e049
+              r3d4b23fa
+//                               -*- Mode: C -*-
 //
 // Cforall Version 1.0.0 Copyright (C) 2017 University of Waterloo
 …
 // Created On       : Mon Feb  6 16:07:02 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Jul 21 23:05:52 2017
 // Update Count     : 3
+// Last Modified On : Mon Feb  6 16:08:21 2017
+// Update Count     : 2
 //

src/tests/avltree/avl-private.h

-              r0720e049
+              r3d4b23fa
 #pragma once
+#ifndef AVL_PRIVATE_H
 #include "avl.h"
 …
 forall(otype K | Comparable(K), otype V)
 int height(tree(K, V) * t);
+#endif

src/tests/avltree/avl.h

-              r0720e049
+              r3d4b23fa
+#pragma once
+#ifndef AVL_TREE_H
+#define AVL_TREE_H
 extern "C" {
 …
 //     printTree(t, 0);
 // }
+#endif

src/tests/designations.c

-              r0720e049
+              r3d4b23fa
 // Author           : Rob Schluntz
 // Created On       : Thu Jun 29 15:26:36 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Jul 27 11:46:35 2017
 // Update Count     : 3
+// Last Modified By : Rob Schluntz
+// Last Modified On : Thu Jun 29 15:27:05 2017
+// Update Count     : 2
 //
 …
 };
-struct Fred {
-    double i[3];
-    int j;
-    struct Mary {
-        struct Jane {
-            double j;
-        } j;
-        double i;
-    } m;
-};
-struct Fred s1 @= { .m.j : 3 };
-struct Fred s2 @= { .i : { [2] : 2 } };
 int main() {
         // simple designation case - starting from beginning of structure, leaves ptr default-initialized (zero)
 …
         };
 #endif
+        // array designation
+        int i[2] = { [1] : 3 };
         // allowed to have 'too many' initialized lists - essentially they are ignored.
         int i1 = { 3 };
 …
         const char * str0 = "hello";
         char str1[] = "hello";
-        const char c1[] = "abc";
-        const char c2[] = { 'a', 'b', 'c' };
-        const char c3[][2] = { { 'a', 'b' }, { 'c', 'd'}, { 'c', 'd'} };
+}

src/tests/except-0.c

-              r0720e049
+              r3d4b23fa
 #include <stdbool.h>
-// Local type to mark exits from scopes. (see ERROR)
 struct signal_exit {
         const char * area;
 …
+}
+// Local Exception Types and manual vtable types.
+//#define TRIVIAL_EXCEPTION(name) //TRIVAL_EXCEPTION(yin)
+struct yin;
+struct yin_vtable {
+        struct exception_t_vtable const * parent;
+        size_t size;
+    void (*copy)(yin *this, yin * other);
+    void (*free)(yin *this);
+    const char (*msg)(yin *this);
+};
+struct yin {
+        struct yin_vtable const * parent;
+};
+void yin_msg(yin) {
+        return "in";
+}
+yin_vtable _yin_vtable_instance = {
+        &_exception_t_vtable_instance, sizeof(yin), ?{}, ^?{}, yin_msg
+}
+void terminate(exception * except_value) {
+void terminate(int except_value) {
         signal_exit a = {"terminate function"};
         throw except_value;
 …
+}
 void resume(exception * except_value) {
+void resume(int except_value) {
         signal_exit a = {"resume function"};
         throwResume except_value;

src/tests/gmp.c

-              r0720e049
+              r3d4b23fa
 // Created On       : Tue Apr 19 08:55:51 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Jul 13 16:35:01 2017
 // Update Count     : 541
+// Last Modified On : Wed May 24 22:05:38 2017
+// Update Count     : 540
 //
 …
 // Local Variables: //
 // tab-width: 4 //
 // compile-command: "cfa gmp.c -lgmp" //
+// compile-command: "cfa gmp.c -l gmp" //
 // End: //

src/tests/math.c

-              r0720e049
+              r3d4b23fa
 // Created On       : Fri Apr 22 14:59:21 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed Aug  9 07:20:49 2017
 // Update Count     : 77
+// Last Modified On : Wed May 24 13:04:33 2017
+// Update Count     : 71
 //
 …
         l = remquo( 3.6L, 0.5L, &quot );
         sout | quot | l | endl;
+        sout | "div:" | div( 3.6F, 0.5F ) | div( 3.6D, 0.5D ) | div( 3.6L, 0.5L ) | endl;
+        f = div( 3.6F, 0.5F, &quot );
+        sout | "div:" | quot | f;
+        d = div( 3.6D, 0.5F, &quot );
+        sout | quot | d;
+        l = div( 3.6L, 0.5L, &quot );
+        sout | quot | l | endl;
         sout | "fma:" | fma( 3.0F, -1.0F, 1.0F ) | fma( 3.0D, -1.0D, 1.0D ) | fma( 3.0L, -1.0L, , 1.0L ) | endl;
         sout | "fdim:" | fdim( 1.0F, -1.0F ) | fdim( 1.0D, -1.0D ) | fdim( 1.0L, -1.0L ) | endl;
 …
         sout | "exp2:" | exp2( 1.0F ) | exp2( 1.0D ) | exp2( 1.0L ) | endl;
         sout | "expm1:" | expm1( 1.0F ) | expm1( 1.0D ) | expm1( 1.0L ) | endl;
-        sout | "pow:" | pow( 1.0F, 1.0F ) | pow( 1.0D, 1.0D ) | pow( 1.0L, 1.0L ) | pow( 1.0F+1.0FI, 1.0F+1.0FI ) | pow( 1.0D+1.0DI, 1.0D+1.0DI ) | pow( 1.0DL+1.0LI, 1.0DL+1.0LI ) | endl;
-        int b = 4;
-        unsigned int e = 2;
-    b \= e;
-    sout | b | b \ e | endl;
-    sout | 'a' \ 3u | 2 \ 8u | 4 \ 3u | -4 \ 3u | 4 \ -3 | -4 \ -3 | 4.0 \ 2.1 | (1.0f+2.0fi) \ (3.0f+2.0fi) | endl;
-        //---------------------- Logarithm ----------------------
         sout | "log:" | log( 1.0F ) | log( 1.0D ) | log( 1.0L ) | log( 1.0F+1.0FI ) | log( 1.0D+1.0DI ) | log( 1.0DL+1.0LI ) | endl;
         sout | "log2:" | log2( 8.0F ) | log2( 8.0D ) | log2( 8.0L ) | endl;
 …
         sout | "logb:" | logb( 8.0F ) | logb( 8.0D ) | logb( 8.0L ) | endl;
+        //---------------------- Power ----------------------
         sout | "sqrt:" | sqrt( 1.0F ) | sqrt( 1.0D ) | sqrt( 1.0L ) | sqrt( 1.0F+1.0FI ) | sqrt( 1.0D+1.0DI ) | sqrt( 1.0DL+1.0LI ) | endl;
         sout | "cbrt:" | cbrt( 27.0F ) | cbrt( 27.0D ) | cbrt( 27.0L ) | endl;
         sout | "hypot:" | hypot( 1.0F, -1.0F ) | hypot( 1.0D, -1.0D ) | hypot( 1.0L, -1.0L ) | endl;
+        sout | "pow:" | pow( 1.0F, 1.0F ) | pow( 1.0D, 1.0D ) | pow( 1.0L, 1.0L ) | pow( 1.0F+1.0FI, 1.0F+1.0FI ) | pow( 1.0D+1.0DI, 1.0D+1.0DI ) | pow( 1.0DL+1.0LI, 1.0DL+1.0LI ) | endl;
         //---------------------- Trigonometric ----------------------
 …
         sout | di | d;
         l = modf( 2.3L, &ldi );
+        sout | ldi | l | endl;
+        sout | "modf:" | modf( 2.3F ) | modf( 2.3D ) | modf( 2.3L ) | endl;
+        sout | ldi | l;
         sout | "nextafter:" | nextafter( 2.0F, 3.0F ) | nextafter( 2.0D, 3.0D ) | nextafter( 2.0L, 3.0L ) | endl;
         sout | "nexttoward:" | nexttoward( 2.0F, 3.0F ) | nexttoward( 2.0D, 3.0D ) | nexttoward( 2.0L, 3.0L ) | endl;

src/tests/maybe.c

-              r0720e049
+              r3d4b23fa
 // Author           : Andrew Beach
 // Created On       : Thr May 25 16:02:00 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Jul 20 15:24:07 2017
 // Update Count     : 1
+// Last Modified By : Andrew Beach
+// Last Modified On : Fri May 16 15:43:00 2017
+// Update Count     : 0
 //
 #include <assert.h>
+#include <assert>
 #include <containers/maybe>

src/tests/preempt_longrun/Makefile.am

-              r0720e049
+              r3d4b23fa
 CC = @CFA_BINDIR@/@CFA_NAME@
 TESTS = block create disjoint enter enter3 processor stack wait yield
+TESTS = barge block create disjoint enter enter3 processor stack wait yield
 .INTERMEDIATE: ${TESTS}
 all-local: ${TESTS:=.run}
-clean-local:
-        rm -f ${TESTS}
 % : %.c ${CC}

src/tests/preempt_longrun/Makefile.in

-              r0720e049
+              r3d4b23fa
 REPEAT = ${abs_top_srcdir}/tools/repeat -s
 BUILD_FLAGS = -g -Wall -Wno-unused-function -quiet @CFA_FLAGS@ -debug -O2 -DPREEMPTION_RATE=${preempt}
 TESTS = block create disjoint enter enter3 processor stack wait yield
+TESTS = barge block create disjoint enter enter3 processor stack wait yield
 all: all-am
 …
                 TEST_LOGS="$$log_list"; \
         exit $$?
+barge.log: barge
+        @p='barge'; \
+        b='barge'; \
+        $(am__check_pre) $(LOG_DRIVER) --test-name "$$f" \
+        --log-file $$b.log --trs-file $$b.trs \
+        $(am__common_driver_flags) $(AM_LOG_DRIVER_FLAGS) $(LOG_DRIVER_FLAGS) -- $(LOG_COMPILE) \
+        "$$tst" $(AM_TESTS_FD_REDIRECT)
 block.log: block
         @p='block'; \
 …
 clean: clean-am
 clean-am: clean-generic clean-local mostlyclean-am
+clean-am: clean-generic mostlyclean-am
 distclean: distclean-am
 …
 .PHONY: all all-am all-local check check-TESTS check-am clean \
         clean-generic clean-local cscopelist-am ctags-am distclean \
+        clean-generic cscopelist-am ctags-am distclean \
         distclean-generic distdir dvi dvi-am html html-am info info-am \
         install install-am install-data install-data-am install-dvi \
 …
 all-local: ${TESTS:=.run}
-clean-local:
-        rm -f ${TESTS}
 % : %.c ${CC}
         ${AM_V_GEN}${CC} ${CFLAGS} ${<} -o ${@}

src/tests/preempt_longrun/create.c

-              r0720e049
+              r3d4b23fa
 #include <kernel>
 #include <thread>
-static const unsigned long N = 2_000ul;
 #ifndef PREEMPTION_RATE
 …
 int main(int argc, char* argv[]) {
         processor p;
         for(int i = 0; i < N; i++) {
+        for(int i = 0; i < 10_000ul; i++) {
                 worker_t w[7];
+        }

src/tests/preempt_longrun/enter.c

r0720e049	r3d4b23fa
3	3	#include <thread>
4	4
	5	#undef N
5	6	static const unsigned long N = 70_000ul;
6	7

src/tests/preempt_longrun/enter3.c

r0720e049	r3d4b23fa
3	3	#include <thread>
4	4
	5	#undef N
5	6	static const unsigned long N = 50_000ul;
6	7

src/tests/preempt_longrun/processor.c

-              r0720e049
+              r3d4b23fa
 #include <kernel>
 #include <thread>
-static const unsigned long N = 5_000ul;
 #ifndef PREEMPTION_RATE
 …
 int main(int argc, char* argv[]) {
         for(int i = 0; i < N; i++) {
+        for(int i = 0; i < 10_000ul; i++) {
                 processor p;
+        }

src/tests/preempt_longrun/yield.c

-              r0720e049
+              r3d4b23fa
 #include <kernel>
 #include <thread>
-static const unsigned long N = 325_000ul;
 #ifndef PREEMPTION_RATE
 …
 void main(worker_t * this) {
         for(int i = 0; i < N; i++) {
+        for(int i = 0; i < 325_000ul; i++) {
                 yield();
+        }

src/tests/result.c

-              r0720e049
+              r3d4b23fa
 // Author           : Andrew Beach
 // Created On       : Thr May 25 16:50:00 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Jul 20 15:24:12 2017
 // Update Count     : 1
+// Last Modified By : Andrew Beach
+// Last Modified On : Fri Jun 16 15:42:00 2017
+// Update Count     : 0
 //
 #include <assert.h>
+#include <assert>
 #include <containers/result>

src/tests/sched-int-barge.c

-              r0720e049
+              r3d4b23fa
 #include <thread>
-static const unsigned long N = 50_000ul;
-#ifndef PREEMPTION_RATE
-#define PREEMPTION_RATE 10_000ul
-#endif
-unsigned int default_preemption() {
-        return 0;
+}
 enum state_t { WAIT, SIGNAL, BARGE };
 …
 monitor global_data_t {
         volatile bool done;
+        bool done;
         int counter;
         state_t state;
 …
                 c->do_wait2 = ((unsigned)rand48()) % (c->do_signal);
                 if(c->do_wait1 == c->do_wait2) sout | "Same" | endl;
+                // if(c->do_wait1 == c->do_wait2) sout | "Same" | endl;
+        }
 …
+        }
         if( c->counter >= N ) c->done = true;
+        if( c->counter >= 100_000 ) c->done = true;
         return !c->done;
+}
 …
+}
-static thread_desc * volatile the_threads;
 int main(int argc, char* argv[]) {
+        rand48seed(0);
+        processor p;
+        {
+                Threads t[17];
+                the_threads = (thread_desc*)t;
+        }
+        rand48seed(0);
+        processor p;
+        {
+                Threads t[17];
+        }
+}

src/tests/sched-int-block.c

-              r0720e049
+              r3d4b23fa
 #include <thread>
+#include <time.h>
+static const unsigned long N = 5_000ul;
+#ifndef PREEMPTION_RATE
+#define PREEMPTION_RATE 10_000ul
+#ifndef N
+#define N 10_000
 #endif
-unsigned int default_preemption() {
-        return PREEMPTION_RATE;
+}
 enum state_t { WAITED, SIGNAL, BARGE };
 …
 int main(int argc, char* argv[]) {
         rand48seed( time( NULL ) );
+        rand48seed(0);
         done = false;
         processor p;

src/tests/sched-int-disjoint.c

-              r0720e049
+              r3d4b23fa
 #include <thread>
+static const unsigned long N = 10_000ul;
+#ifndef PREEMPTION_RATE
+#define PREEMPTION_RATE 10_000ul
+#ifndef N
+#define N 10_000
 #endif
-unsigned int default_preemption() {
-        return PREEMPTION_RATE;
+}
 enum state_t { WAIT, SIGNAL, BARGE };

src/tests/sched-int-wait.c

-              r0720e049
+              r3d4b23fa
 #include <thread>
+static const unsigned long N = 10_000ul;
+#ifndef PREEMPTION_RATE
+#define PREEMPTION_RATE 10_000ul
+#ifndef N
+#define N 10_000
 #endif
-unsigned int default_preemption() {
-        return PREEMPTION_RATE;
+}
 monitor global_t {};
 …
 int main(int argc, char* argv[]) {
         waiter_left = 4;
         processor p[2];
+        processor p;
         sout | "Starting" | endl;
+        {

src/tests/test.py

-              r0720e049
+              r3d4b23fa
                 if   retcode == TestResult.SUCCESS:     result_txt = "Done"
                 elif retcode == TestResult.TIMEOUT:     result_txt = "TIMEOUT"
                 else :                                          result_txt = "ERROR code %d" % retcode
+                else :                                          result_txt = "ERROR"
         else :
                 if   retcode == TestResult.SUCCESS:     result_txt = "PASSED"
                 elif retcode == TestResult.TIMEOUT:     result_txt = "TIMEOUT"
                 else :                                          result_txt = "FAILED with code %d" % retcode
+                else :                                          result_txt = "FAILED"
         #print result with error if needed

src/tests/vector/array.h

-              r0720e049
+              r3d4b23fa
 // Author           : Richard C. Bilson
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 10:04:20 2017
 // Update Count     : 6
+// Last Modified By : Rob Schluntz
+// Last Modified On : Wed Apr 27 17:26:04 2016
+// Update Count     : 5
 //
+#pragma once
+#ifndef ARRAY_H
+#define ARRAY_H
 //#include <iterator>
 …
 elt_type * end( array_type * array );
+#endif // ARRAY_H
 // Local Variables: //
 // tab-width: 4 //

src/tests/vector/vector_int.h

-              r0720e049
+              r3d4b23fa
 // Author           : Richard C. Bilson
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 10:04:02 2017
 // Update Count     : 4
+// Last Modified By : Rob Schluntz
+// Last Modified On : Wed Apr 27 17:26:59 2016
+// Update Count     : 2
 //
+#pragma once
+#ifndef VECTOR_INT_H
+#define VECTOR_INT_H
 // A flexible array, similar to a C++ vector, that holds integers and can be resized dynamically
 …
 void ?{}( vector_int * );                                                               // allocate vector with default capacity
 void ?{}( vector_int *, int reserve );                                  // allocate vector with specified capacity
 void ?{}( vector_int * vec, vector_int other );                 // copy constructor
+void ?{}( vector_int *, int reserve );          // allocate vector with specified capacity
+void ?{}( vector_int * vec, vector_int other ); // copy constructor
 void ^?{}( vector_int * );                                                              // deallocate vector's storage
 …
 lvalue int ?[?]( vector_int * vec, int index );                 // access to arbitrary element (does not resize)
+int last( vector_int * vec );                                                   // return last element
+int last( vector_int * vec );                                                           // return last element
+#endif // VECTOR_INT_H
 // Local Variables: //

tools/cfa.nanorc

-              r0720e049
+              r3d4b23fa
 # Types
 color green "\<(forall|trait|(o|d|f|t)type|mutex|_Bool|volatile|virtual)\>"
+color green "\<(forall|otype|dtype|ftype|trait|mutex|_Bool|volatile)\>"
 color green "\<(float|double|bool|char|int|short|long|sizeof|enum|void|auto)\>"
 color green "\<(static|const|struct|union|typedef|extern|(un)?signed|inline)\>"
 …
 # Declarations
+color brightgreen "\<(struct|union|typedef|trait|coroutine|monitor|thread)\>"
+color brightgreen "\<(with)\>"
+color brightgreen "\<(struct|union|typedef|trait|coroutine|monitor)\>"
 # Control Flow Structures

tools/prettyprinter/ParserTypes.h

-              r0720e049
+              r3d4b23fa
 // Created On       : Sun Dec 16 15:00:49 2001
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 10:13:09 2017
 // Update Count     : 175
+// Last Modified On : Wed Jun 28 22:59:27 2017
+// Update Count     : 174
 //
+#pragma once
+#ifndef __PARSER_HH__
+#define __PARSER_HH__
 int yylex();
 …
 #include "token.h"
+#endif // __PARSER_HH__
 // Local Variables: //
 // mode: c++ //

tools/prettyprinter/filter.h

-              r0720e049
+              r3d4b23fa
 // Created On       : Tue Apr  9 22:31:18 2002
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 10:12:55 2017
 // Update Count     : 11
+// Last Modified On : Thu Jun 29 08:28:32 2017
+// Update Count     : 10
 //
+#pragma once
+#ifndef __FILTER_H__
+#define __FILTER_H__
 #include "ParserTypes.h"
 …
 void HTML( Token * tree );
+#endif // __FILTER_H__
 // Local Variables: //
 // mode: c++ //

tools/prettyprinter/lex.ll

-              r0720e049
+              r3d4b23fa
+/*
+/*                               -*- Mode: C -*-
+ *
  * Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
+ *
 …
  * Created On       : Sat Dec 15 11:45:59 2001
  * Last Modified By : Peter A. Buhr
  * Last Modified On : Fri Jul 21 23:06:16 2017
  * Update Count     : 254
+ * Last Modified On : Wed Jun 28 22:57:17 2017
+ * Update Count     : 253
  */

tools/prettyprinter/test.y

-              r0720e049
+              r3d4b23fa
+        ;
+rules1  :
+        /* empty */
+        {}
+rules1  : /* empty */
         | xxx
           /* fred */ yyy

tools/prettyprinter/token.cc

-              r0720e049
+              r3d4b23fa
+//                              -*- Mode: C++ -*-
 //
+// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
+//
+// The contents of this file are covered under the licence agreement in the
+// file "LICENCE" distributed with Cforall.
+// Copyright (C) Peter A. Buhr 2017
 //
 // Pretty Printer, Copyright (C) Richard C. Bilson and Rodolfo G. Esteves 2001
 …
 // Created On       : Wed Jun 28 22:46:23 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Jul 21 23:07:04 2017
 // Update Count     : 10
+// Last Modified On : Thu Jun 29 09:33:49 2017
+// Update Count     : 9
 //

tools/prettyprinter/token.h

-              r0720e049
+              r3d4b23fa
 // Created On       : Wed Jun 28 22:47:58 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 10:12:42 2017
 // Update Count     : 6
+// Last Modified On : Wed Jun 28 23:02:06 2017
+// Update Count     : 5
 //
+#pragma once
+#ifndef __TOKEN_H__
+#define __TOKEN_H__
 struct Token {
 …
 };
+#endif // __TOKEN_H__
 // Local Variables: //
 // tab-width: 4 //

Context Navigation

Changes in / [0720e049:3d4b23fa]

Legend: