Context Navigation

-                      rb8508a2
+                      rb87a5ed
 ======================================
+Cforall is built using GNU Make and the GNU Autoconf system.  It also
+requires g++ version 3, bison and flex.  On systems where GNU Make is
+the default make it may suffice to build the system by entering the
+commands
+Cforall is built using GNU Make and the GNU Autoconf system.  It also requires
+g++ version 3, bison and flex.  On systems where GNU Make is the default make
+it may suffice to build the system by entering the commands
         ./configure
 …
 Options for 'configure'
 -----------------------
 The script 'configure' accepts many command line arguments.  Run
+'./configure --help' to see a list of all of them.  This document
 attempts to summarize the most useful arguments.
+The script 'configure' accepts many command line arguments.  Run './configure
+--help' to see a list of all of them.  This document attempts to summarize the
+most useful arguments.
+--prefix=/some/directory controls the path prefix common to all
+installed cfa-cc components.  Some components will be installed in
+/some/directory/bin, others in /some/directory/lib.  If unspecified,
+this defaults to /usr/local.
+--prefix=/some/directory controls the path prefix common to all installed
+cfa-cc components.  Some components will be installed in /some/directory/bin,
+others in /some/directory/lib.  If unspecified, this defaults to /usr/local.
+--with-backend-compiler=PROGRAM specifies the installed path of gcc
+.2.  It defaults to the first command named 'gcc' in the current
+PATH.
+--with-backend-compiler=PROGRAM specifies the installed path of gcc 3.2.  It
+defaults to the first command named 'gcc' in the current PATH.
 cfa-cc itself is built with the version of g++ specified by the
+environment variable CXX.  If CXX is unset, cfa-cc is built using the
 first command named 'g++' in the current PATH.
+cfa-cc itself is built with the version of g++ specified by the environment
+variable CXX.  If CXX is unset, cfa-cc is built using the first command named
+'g++' in the current PATH.

Makefile.in

-                      rb8508a2
+                      rb87a5ed
         $(top_srcdir)/libcfa/Makefile.in \
         $(top_srcdir)/translator/Makefile.in \
         $(top_srcdir)/translator/examples/Makefile.in AUTHORS COPYING \
         ChangeLog INSTALL NEWS install-sh missing mkinstalldirs
+        $(top_srcdir)/translator/examples/Makefile.in AUTHORS INSTALL \
+        TODO install-sh missing mkinstalldirs
 ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
 am__aclocal_m4_deps = $(top_srcdir)/configure.in
 …
           case '$(am__configure_deps)' in \
             *$$dep*) \
               echo ' cd $(srcdir) && $(AUTOMAKE) --gnu'; \
               $(am__cd) $(srcdir) && $(AUTOMAKE) --gnu \
+              echo ' cd $(srcdir) && $(AUTOMAKE) --foreign'; \
+              $(am__cd) $(srcdir) && $(AUTOMAKE) --foreign \
                 && exit 0; \
               exit 1;; \
           esac; \
         done; \
         echo ' cd $(top_srcdir) && $(AUTOMAKE) --gnu Makefile'; \
+        echo ' cd $(top_srcdir) && $(AUTOMAKE) --foreign Makefile'; \
         $(am__cd) $(top_srcdir) && \
           $(AUTOMAKE) --gnu Makefile
+          $(AUTOMAKE) --foreign Makefile
 .PRECIOUS: Makefile
 Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status

configure

-                      rb8508a2
+                      rb87a5ed
 # Define the identity of the package.
  PACKAGE=cfa
  VERSION=1.0
+ PACKAGE='cfa-cc'
+ VERSION='1.0'
 …
+                # do not follow GNU standard
 ac_config_headers="$ac_config_headers config.h"
 …
 { $as_echo "$as_me:${as_lineno-$LINENO}: result: The Cforall translator is now configured for your system" >&5
 $as_echo "The Cforall translator is now configured for your system" >&6; }
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: Cforall configuraton completed. Type \"make install\"." >&5
+$as_echo "Cforall configuraton completed. Type \"make install\"." >&6; }

configure.in

-                      rb8508a2
+                      rb87a5ed
 AC_CONFIG_SRCDIR([translator/main.cc])
 AM_INIT_AUTOMAKE(cfa, 1.0)
+AM_INIT_AUTOMAKE([foreign])             # do not follow GNU standard
 AM_CONFIG_HEADER(config.h)
 …
 dnl Final text
+AC_MSG_RESULT(The Cforall translator is now configured for your system)
+dnl AC_MSG_RESULT()
+dnl AC_MSG_RESULT(Perhaps you'd like to inspect the created Makefiles)
+AC_MSG_RESULT(Cforall configuraton completed. Type "make install".)

driver/Makefile.in

-                      rb8508a2
+                      rb87a5ed
+###
+### This file is part of the Cforall project
+###
+### $Id: Makefile.in,v 1.5 2005/08/26 19:16:54 rcbilson Exp $
+###
+######################### -*- Mode: Makefile-Gmake -*- ########################$
+##
+## 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.
+##
+## Makefile.in --
+##
+## Author           : Peter A. Buhr
+## Created On       : Sat May 16 07:50:15 2015
+## Last Modified By : Peter A. Buhr
+## Last Modified On : Sat May 16 08:34:55 2015
+## Update Count     : 4
+###############################################################################
 CXX=@CXX@
 …
 SRCS:=cfa.cc cc1.cc
 OBJECTS:=$(SRCS:.cc=.o)
 DEPS:=$(SRCS:.cc=.d)
+OBJECTS:=${SRCS:.cc=.o}
+DEPS:=${SRCS:.cc=.d}
 all: cfa cc1
 cfa: cfa.o
         $(CXX) $< -o $@
+        ${CXX} $< -o $@
 cc1 : cc1.o
         $(CXX) $< -o $@
+        ${CXX} $< -o $@
 install: cfa cc1
         $(INSTALL) -d @CFA_BINDIR@
         $(INSTALL) -d @CFA_LIBDIR@
         $(INSTALL) cc1 @CFA_LIBDIR@
         $(INSTALL) cfa @CFA_BINDIR@
+        ${INSTALL} -d @CFA_BINDIR@
+        ${INSTALL} -d @CFA_LIBDIR@
+        ${INSTALL} cc1 @CFA_LIBDIR@
+        ${INSTALL} cfa @CFA_BINDIR@
 clean:
         rm -f cfa cc1 $(OBJECTS) $(DEPS) core
+        rm -f cfa cc1 ${OBJECTS} ${DEPS} core

driver/cc1.cc

-                      rb8508a2
+                      rb87a5ed
+//                              -*- Mode: C++ -*-
+//
+// CForall Version 1.0, Copyright (C) Peter A. Buhr 2005
+//
+//
+// 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.
+//
 // cc1.cc --
 //
 // Author           : Richard C. Bilson
+//
+// Author           : Peter A. Buhr
 // Created On       : Fri Aug 26 14:23:51 2005
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu May 14 13:24:45 2015
 // Update Count     : 43
+// Last Modified On : Sat May 16 07:42:14 2015
+// Update Count     : 49
 //
 #include <iostream>
 …
 #include <string>
 using std::string;
 #include <cstdio>                                       // stderr, stdout, perror, fprintf
 #include <cstdlib>                                      // getenv, exit, mkstemp
 #include <unistd.h>                                     // execvp, fork, unlink
 #include <sys/wait.h>                                   // wait
 #include "config.h"                                     // configure info
+#include <cstdio>                                                                               // stderr, stdout, perror, fprintf
+#include <cstdlib>                                                                              // getenv, exit, mkstemp
+#include <unistd.h>                                                                             // execvp, fork, unlink
+#include <sys/wait.h>                                                                   // wait
+#include "config.h"                                                                             // configure info
 …
 string compiler_name( GCC_PATH );                       // path/name of C compiler
+string compiler_name( GCC_PATH );                                               // path/name of C compiler
 string D__GCC_BPREFIX__( "-D__GCC_BPREFIX__=" );
 …
 bool prefix( string arg, string pre ) {
     return arg.substr( 0, pre.size() ) == pre;
+        return arg.substr( 0, pre.size() ) == pre;
 } // prefix
 void checkEnv( const char *args[], int &nargs ) {
+    char *value;
+    value = getenv( "__COMPILER__" );
+    if ( value != NULL ) {
+        compiler_name = value;
+#ifdef __DEBUG_H__
+        cerr << "env arg:\"" << compiler_name << "\"" << endl;
+#endif // __DEBUG_H__
+    } // if
+    value = getenv( "__GCC_MACHINE__" );
+    if ( value != NULL ) {
+        args[nargs] = ( *new string( value ) ).c_str(); // pass the argument along
+#ifdef __DEBUG_H__
+        cerr << "env arg:\"" << args[nargs] << "\"" << endl;
+#endif // __DEBUG_H__
+        char *value;
+        value = getenv( "__COMPILER__" );
+        if ( value != NULL ) {
+                compiler_name = value;
+#ifdef __DEBUG_H__
+                cerr << "env arg:\"" << compiler_name << "\"" << endl;
+#endif // __DEBUG_H__
+        } // if
+        value = getenv( "__GCC_MACHINE__" );
+        if ( value != NULL ) {
+                args[nargs] = ( *new string( value ) ).c_str(); // pass the argument along
+#ifdef __DEBUG_H__
+                cerr << "env arg:\"" << args[nargs] << "\"" << endl;
+#endif // __DEBUG_H__
+                nargs += 1;
+        } // if
+        value = getenv( "__GCC_VERSION__" );
+        if ( value != NULL ) {
+                args[nargs] = ( *new string( value ) ).c_str(); // pass the argument along
+#ifdef __DEBUG_H__
+                cerr << "env arg:\"" << args[nargs] << "\"" << endl;
+#endif // __DEBUG_H__
+                nargs += 1;
+        } // if
+} // checkEnv
+void rmtmpfile() {
+        if ( unlink( tmpname ) == -1 ) {                                        // remove tmpname
+                perror ( "CFA Translator error: cpp failed" );
+                exit( EXIT_FAILURE );
+        } // if
+        tmpfilefd = -1;                                                                         // mark closed
+} // rmtmpfile
+void sigTermHandler( int signal ) {
+        if ( tmpfilefd != -1 ) {                                                        // RACE, file created ?
+                rmtmpfile();                                                                    // remove
+                exit( EXIT_FAILURE );                                                   // terminate
+        } // if
+} // sigTermHandler
+void Stage1( const int argc, const char * const argv[] ) {
+        int code;
+        int i;
+        string arg;
+        string bprefix;
+        const char *cpp_in = NULL;
+        const char *cpp_out = NULL;
+        bool CFA_flag = false;
+        bool cpp_flag = false;
+        const char *o_name = NULL;
+        const char *args[argc + 100];                                           // leave space for 100 additional cpp command line values
+        int nargs = 1;                                                                          // number of arguments in args list; 0 => command name
+        const char *uargs[20];                                                          // leave space for 20 additional cfa-cpp command line values
+        int nuargs = 1;                                                                         // 0 => command name
+        signal( SIGINT,  sigTermHandler );
+        signal( SIGTERM, sigTermHandler );
+        // process all the arguments
+        checkEnv( args, nargs );                                                        // arguments passed via environment variables
+        for ( i = 1; i < argc; i += 1 ) {
+#ifdef __DEBUG_H__
+                cerr << "argv[" << i << "]:\"" << argv[i] << "\"" << endl;
+#endif // __DEBUG_H__
+                arg = argv[i];
+#ifdef __DEBUG_H__
+                cerr << "arg:\"" << arg << "\"" << endl;
+#endif // __DEBUG_H__
+                if ( prefix( arg, "-" ) ) {
+                        // strip g++ flags that are inappropriate or cause duplicates in subsequent passes
+                        if ( arg == "-quiet" ) {
+                        } else if ( arg == "-imultilib" || arg == "-imultiarch" ) {
+                                i += 1;                                                                 // and the argument
+                        } else if ( prefix( arg, "-A" ) ) {
+                        } else if ( prefix( arg, "-D__GNU" ) ) {
+                                //********
+                                // GCC 5.6.0 SEPARATED THE -D FROM THE ARGUMENT!
+                                //********
+                        } else if ( arg == "-D" && prefix( argv[i + 1], "__GNU" ) ) {
+                                i += 1;                                                                 // and the argument
+                                // strip flags controlling cpp step
+                        } else if ( arg == "-D__CPP__" ) {
+                                cpp_flag = true;
+                        } else if ( arg == "-D" && string( argv[i + 1] ) == "__CPP__" ) {
+                                i += 1;                                                                 // and the argument
+                                cpp_flag = true;
+                        } else if ( arg == "-D__CFA__" ) {
+                                CFA_flag = true;
+                        } else if ( arg == "-D" && string( argv[i + 1] ) == "__CFA__" ) {
+                                i += 1;                                                                 // and the argument
+                                CFA_flag = true;
+                        } else if ( prefix( arg, D__CFA_FLAGPREFIX__ ) ) {
+                                uargs[nuargs] = ( *new string( arg.substr( D__CFA_FLAGPREFIX__.size() ) ) ).c_str();
+                                nuargs += 1;
+                        } else if ( arg == "-D" && prefix( argv[i + 1], D__CFA_FLAGPREFIX__.substr(2) ) ) {
+                                uargs[nuargs] = ( *new string( string( argv[i + 1] ).substr( D__CFA_FLAGPREFIX__.size() - 2 ) ) ).c_str();
+                                nuargs += 1;
+                                i += 1;                                                                 // and the argument
+                        } else if ( prefix( arg, D__GCC_BPREFIX__ ) ) {
+                                bprefix = arg.substr( D__GCC_BPREFIX__.size() );
+                        } else if ( arg == "-D" && prefix( argv[i + 1], D__GCC_BPREFIX__.substr(2) ) ) {
+                                bprefix = string( argv[i + 1] ).substr( D__GCC_BPREFIX__.size() - 2 );
+                                i += 1;                                                                 // and the argument
+                                // all other flags
+                        } else if ( arg == "-o" ) {
+                                i += 1;
+                                o_name = argv[i];
+                        } else {
+                                args[nargs] = argv[i];                                  // pass the flag along
+                                nargs += 1;
+                                // CPP flags with an argument
+                                if ( arg == "-D" || arg == "-I" || arg == "-MF" || arg == "-MT" || arg == "-MQ" ||
+                                         arg == "-include" || arg == "-imacros" || arg == "-idirafter" || arg == "-iprefix" ||
+                                         arg == "-iwithprefix" || arg == "-iwithprefixbefore" || arg == "-isystem" || arg == "-isysroot" ) {
+                                        i += 1;
+                                        args[nargs] = argv[i];                          // pass the argument along
+                                        nargs += 1;
+#ifdef __DEBUG_H__
+                                        cerr << "argv[" << i << "]:\"" << argv[i] << "\"" << endl;
+#endif // __DEBUG_H__
+                                } else if ( arg == "-MD" || arg == "-MMD" ) {
+                                        args[nargs] = "-MF";                            // insert before file
+                                        nargs += 1;
+                                        i += 1;
+                                        args[nargs] = argv[i];                          // pass the argument along
+                                        nargs += 1;
+#ifdef __DEBUG_H__
+                                        cerr << "argv[" << i << "]:\"" << argv[i] << "\"" << endl;
+#endif // __DEBUG_H__
+                                } // if
+                        } // if
+                } else {                                                                                // obtain input and possibly output files
+                        if ( cpp_in == NULL ) {
+                                cpp_in = argv[i];
+#ifdef __DEBUG_H__
+                                cerr << "cpp_in:\"" << cpp_in << "\"" << endl;
+#endif // __DEBUG_H__
+                        } else if ( cpp_out == NULL ) {
+                                cpp_out = argv[i];
+#ifdef __DEBUG_H__
+                                cerr << "cpp_out:\"" << cpp_out << "\""<< endl;
+#endif // __DEBUG_H__
+                        } else {
+                                cerr << "Usage: " << argv[0] << " input-file [output-file] [options]" << endl;
+                                exit( EXIT_FAILURE );
+                        } // if
+                } // if
+        } // for
+#ifdef __DEBUG_H__
+        cerr << "args:";
+        for ( i = 1; i < nargs; i += 1 ) {
+                cerr << " " << args[i];
+        } // for
+        if ( cpp_in != NULL ) cerr << " " << cpp_in;
+        if ( cpp_out != NULL ) cerr << " " << cpp_out;
+        cerr << endl;
+#endif // __DEBUG_H__
+        if ( cpp_in == NULL ) {
+                cerr << "Usage: " << argv[0] << " input-file [output-file] [options]" << endl;
+                exit( EXIT_FAILURE );
+        } // if
+        if ( cpp_flag ) {
+                // The -E flag is specified on the cfa command so only run the preprocessor and output is written to standard
+                // output or -o. The call to cfa has a -E so it does not have to be added to the argument list.
+                args[0] = compiler_name.c_str();
+                args[nargs] = cpp_in;
+                nargs += 1;
+                if ( o_name != NULL ) {                                                 // location for output
+                        args[nargs] = "-o";
+                        nargs += 1;
+                        args[nargs] = o_name;
+                        nargs += 1;
+                } // if
+                args[nargs] = NULL;                                                             // terminate argument list
+#ifdef __DEBUG_H__
+                cerr << "nargs: " << nargs << endl;
+                for ( i = 0; args[i] != NULL; i += 1 ) {
+                        cerr << args[i] << " ";
+                } // for
+                cerr << endl;
+#endif // __DEBUG_H__
+                execvp( args[0], (char *const *)args );                 // should not return
+                perror( "CFA Translator error: cpp level, execvp" );
+                exit( EXIT_FAILURE );
+        } // if
+        // Create a temporary file to store output of the C preprocessor.
+        tmpfilefd = mkstemp( tmpname );
+        if ( tmpfilefd == -1 ) {
+                perror( "CFA Translator error: cpp level, mkstemp" );
+                exit( EXIT_FAILURE );
+        } // if
+#ifdef __DEBUG_H__
+        cerr << "tmpname:" << tmpname << " tmpfilefd:" << tmpfilefd << endl;
+#endif // __DEBUG_H__
+        // Run the C preprocessor and save the output in tmpfile.
+        if ( fork() == 0 ) {                                                             // child process ?
+                // -o xxx.ii cannot be used to write the output file from cpp because no output file is created if cpp detects
+                // an error (e.g., cannot find include file). Whereas, output is always generated, even when there is an error,
+                // when cpp writes to stdout. Hence, stdout is redirected into the temporary file.
+                if ( freopen( tmpname, "w", stdout ) == NULL ) { // redirect stdout to tmpname
+                        perror( "CFA Translator error: cpp level, freopen" );
+                        exit( EXIT_FAILURE );
+                } // if
+                args[0] = compiler_name.c_str();
+                args[nargs] = cpp_in;                                                   // input to cpp
+                nargs += 1;
+                args[nargs] = NULL;                                                             // terminate argument list
+#ifdef __DEBUG_H__
+                cerr << "cpp nargs: " << nargs << endl;
+                for ( i = 0; args[i] != NULL; i += 1 ) {
+                        cerr << args[i] << " ";
+                } // for
+                cerr << endl;
+#endif // __DEBUG_H__
+                execvp( args[0], (char *const *)args );                 // should not return
+                perror( "CFA Translator error: cpp level, execvp" );
+                exit( EXIT_FAILURE );
+        } // if
+        wait( &code );                                                                          // wait for child to finish
+#ifdef __DEBUG_H__
+        cerr << "return code from cpp:" << WEXITSTATUS(code) << endl;
+#endif // __DEBUG_H__
+        if ( WIFSIGNALED(code) != 0 ) {                                         // child failed ?
+                rmtmpfile();                                                                    // remove tmpname
+                cerr << "CFA Translator error: cpp failed with signal " << WTERMSIG(code) << endl;
+                exit( EXIT_FAILURE );
+        } // if
+        if ( WEXITSTATUS(code) != 0 ) {                                         // child error ?
+                rmtmpfile();                                                                    // remove tmpname
+                exit( WEXITSTATUS( code ) );                                    // do not continue
+        } // if
+        // If -CFA flag specified, run the cfa-cpp preprocessor on the temporary file, and output is written to standard
+        // output.  Otherwise, run the cfa-cpp preprocessor on the temporary file and save the result into the output file.
+        if ( fork() == 0 ) {                                                            // child runs CFA
+                uargs[0] = ( *new string( bprefix + "/cfa-cpp" ) ).c_str();
+                uargs[nuargs] = "-p";
+                nuargs += 1;
+                uargs[nuargs] = tmpname;
+                nuargs += 1;
+                if ( o_name != NULL ) {
+                        uargs[nuargs] = o_name;
+                        nuargs += 1;
+                } else if ( ! CFA_flag ) {                                              // run cfa-cpp ?
+                        uargs[nuargs] = cpp_out;
+                        nuargs += 1;
+                } // if
+                uargs[nuargs] = NULL;                                                   // terminate argument list
+#ifdef __DEBUG_H__
+                cerr << "cfa-cpp nuargs: " << o_name << " " << CFA_flag << " " << nuargs << endl;
+                for ( i = 0; uargs[i] != NULL; i += 1 ) {
+                        cerr << uargs[i] << " ";
+                } // for
+                cerr << endl;
+#endif // __DEBUG_H__
+                execvp( uargs[0], (char * const *)uargs );              // should not return
+                perror( "CFA Translator error: cpp level, execvp" );
+                exit( EXIT_FAILURE );
+        } // if
+        wait( &code );                                                                          // wait for child to finish
+#ifdef __DEBUG_H__
+        cerr << "return code from cfa-cpp:" << WEXITSTATUS(code) << endl;
+#endif // __DEBUG_H__
+        // Must unlink here because file must exist across execvp.
+        rmtmpfile();                                                                            // remove tmpname
+        if ( WIFSIGNALED(code) ) {                                                      // child failed ?
+                cerr << "CFA Translator error: cfa-cpp failed with signal " << WTERMSIG(code) << endl;
+                exit( EXIT_FAILURE );
+        } // if
+        exit( WEXITSTATUS(code) );
+} // Stage1
+void Stage2( const int argc, const char * const * argv ) {
+        int i;
+        string arg;
+        const char *cpp_in = NULL;
+        const char *args[argc + 100];                                           // leave space for 100 additional cfa command line values
+        int nargs = 1;                                                                          // number of arguments in args list; 0 => command name
+        // process all the arguments
+        checkEnv( args, nargs );                                                        // arguments passed via environment variables
+        for ( i = 1; i < argc; i += 1 ) {
+#ifdef __DEBUG_H__
+                cerr << "argv[" << i << "]:\"" << argv[i] << "\"" << endl;
+#endif // __DEBUG_H__
+                arg = argv[i];
+#ifdef __DEBUG_H__
+                cerr << "arg:\"" << arg << "\"" << endl;
+#endif // __DEBUG_H__
+                if ( prefix( arg, "-" ) ) {
+                        // strip inappropriate flags
+                        if ( arg == "-quiet" || arg == "-version" || arg == "-fpreprocessed" ||
+                                 // Currently CFA does not suppose precompiled .h files.
+                                 prefix( arg, "--output-pch" ) ) {
+                                // strip inappropriate flags with an argument
+                        } else if ( arg == "-auxbase" || arg == "-auxbase-strip" || arg == "-dumpbase" ) {
+                                i += 1;
+#ifdef __DEBUG_H__
+                                cerr << "arg:\"" << argv[i] << "\"" << endl;
+#endif // __DEBUG_H__
+                                // all other flags
+                        } else {
+                                args[nargs] = argv[i];                                  // pass the flag along
+                                nargs += 1;
+                                if ( arg == "-o" ) {
+                                        i += 1;
+                                        args[nargs] = argv[i];                          // pass the argument along
+                                        nargs += 1;
+#ifdef __DEBUG_H__
+                                        cerr << "arg:\"" << argv[i] << "\"" << endl;
+#endif // __DEBUG_H__
+                                } // if
+                        } // if
+                } else {                                                                                // obtain input and possibly output files
+                        if ( cpp_in == NULL ) {
+                                cpp_in = argv[i];
+#ifdef __DEBUG_H__
+                                cerr << "cpp_in:\"" << cpp_in << "\"" << endl;
+#endif // __DEBUG_H__
+                        } else {
+                                cerr << "Usage: " << argv[0] << " input-file [output-file] [options]" << endl;
+                                exit( EXIT_FAILURE );
+                        } // if
+                } // if
+        } // for
+#ifdef __DEBUG_H__
+        cerr << "args:";
+        for ( i = 1; i < nargs; i += 1 ) {
+                cerr << " " << args[i];
+        } // for
+        cerr << endl;
+        if ( cpp_in != NULL ) cerr << " " << cpp_in;
+#endif // __DEBUG_H__
+        args[0] = compiler_name.c_str();
+        args[nargs] = "-S";                                                                     // only compile and put assembler output in specified file
         nargs += 1;
-    } // if
-    value = getenv( "__GCC_VERSION__" );
-    if ( value != NULL ) {
-        args[nargs] = ( *new string( value ) ).c_str(); // pass the argument along
-#ifdef __DEBUG_H__
-        cerr << "env arg:\"" << args[nargs] << "\"" << endl;
-#endif // __DEBUG_H__
-        nargs += 1;
-    } // if
-} // checkEnv
-void rmtmpfile() {
-    if ( unlink( tmpname ) == -1 ) {                    // remove tmpname
-        perror ( "CFA Translator error: cpp failed" );
-        exit( EXIT_FAILURE );
-    } // if
-    tmpfilefd = -1;                                     // mark closed
-} // rmtmpfile
-void sigTermHandler( int signal ) {
-    if ( tmpfilefd != -1 ) {                            // RACE, file created ?
-        rmtmpfile();                                    // remove
-        exit( EXIT_FAILURE );                           // terminate
-    } // if
-} // sigTermHandler
-void Stage1( const int argc, const char * const argv[] ) {
-    int code;
-    int i;
-    string arg;
-    string bprefix;
-    const char *cpp_in = NULL;
-    const char *cpp_out = NULL;
-    bool CFA_flag = false;
-    bool cpp_flag = false;
-    const char *o_name = NULL;
-    const char *args[argc + 100];                       // leave space for 100 additional cpp command line values
-    int nargs = 1;                                      // number of arguments in args list; 0 => command name
-    const char *uargs[20];                              // leave space for 20 additional cfa-cpp command line values
-    int nuargs = 1;                                     // 0 => command name
-    signal( SIGINT,  sigTermHandler );
-    signal( SIGTERM, sigTermHandler );
-    // process all the arguments
-    checkEnv( args, nargs );                            // arguments passed via environment variables
-    for ( i = 1; i < argc; i += 1 ) {
-#ifdef __DEBUG_H__
-        cerr << "argv[" << i << "]:\"" << argv[i] << "\"" << endl;
-#endif // __DEBUG_H__
-        arg = argv[i];
-#ifdef __DEBUG_H__
-        cerr << "arg:\"" << arg << "\"" << endl;
-#endif // __DEBUG_H__
-        if ( prefix( arg, "-" ) ) {
-            // strip g++ flags that are inappropriate or cause duplicates in subsequent passes
-            if ( arg == "-quiet" ) {
-            } else if ( arg == "-imultilib" || arg == "-imultiarch" ) {
-                i += 1;                                 // and the argument
-            } else if ( prefix( arg, "-A" ) ) {
-            } else if ( prefix( arg, "-D__GNU" ) ) {
-            //********
-            // GCC 5.6.0 SEPARATED THE -D FROM THE ARGUMENT!
-            //********
-            } else if ( arg == "-D" && prefix( argv[i + 1], "__GNU" ) ) {
-                i += 1;                                 // and the argument
-            // strip flags controlling cpp step
-            } else if ( arg == "-D__CPP__" ) {
-                cpp_flag = true;
-            } else if ( arg == "-D" && string( argv[i + 1] ) == "__CPP__" ) {
-                i += 1;                                 // and the argument
-                cpp_flag = true;
-            } else if ( arg == "-D__CFA__" ) {
-                CFA_flag = true;
-            } else if ( arg == "-D" && string( argv[i + 1] ) == "__CFA__" ) {
-                i += 1;                                 // and the argument
-                CFA_flag = true;
-            } else if ( prefix( arg, D__CFA_FLAGPREFIX__ ) ) {
-                uargs[nuargs] = ( *new string( arg.substr( D__CFA_FLAGPREFIX__.size() ) ) ).c_str();
-                nuargs += 1;
-            } else if ( arg == "-D" && prefix( argv[i + 1], D__CFA_FLAGPREFIX__.substr(2) ) ) {
-                uargs[nuargs] = ( *new string( string( argv[i + 1] ).substr( D__CFA_FLAGPREFIX__.size() - 2 ) ) ).c_str();
-                nuargs += 1;
-                i += 1;                                 // and the argument
-            } else if ( prefix( arg, D__GCC_BPREFIX__ ) ) {
-                bprefix = arg.substr( D__GCC_BPREFIX__.size() );
-            } else if ( arg == "-D" && prefix( argv[i + 1], D__GCC_BPREFIX__.substr(2) ) ) {
-                bprefix = string( argv[i + 1] ).substr( D__GCC_BPREFIX__.size() - 2 );
-                i += 1;                                 // and the argument
-            // all other flags
-            } else if ( arg == "-o" ) {
-                i += 1;
-                o_name = argv[i];
-            } else {
-                args[nargs] = argv[i];                  // pass the flag along
-                nargs += 1;
-                // CPP flags with an argument
-                if ( arg == "-D" || arg == "-I" || arg == "-MF" || arg == "-MT" || arg == "-MQ" ||
-                     arg == "-include" || arg == "-imacros" || arg == "-idirafter" || arg == "-iprefix" ||
-                     arg == "-iwithprefix" || arg == "-iwithprefixbefore" || arg == "-isystem" || arg == "-isysroot" ) {
-                    i += 1;
-                    args[nargs] = argv[i];              // pass the argument along
-                    nargs += 1;
-#ifdef __DEBUG_H__
-                    cerr << "argv[" << i << "]:\"" << argv[i] << "\"" << endl;
-#endif // __DEBUG_H__
-                } else if ( arg == "-MD" || arg == "-MMD" ) {
-                    args[nargs] = "-MF";                // insert before file
-                    nargs += 1;
-                    i += 1;
-                    args[nargs] = argv[i];              // pass the argument along
-                    nargs += 1;
-#ifdef __DEBUG_H__
-                    cerr << "argv[" << i << "]:\"" << argv[i] << "\"" << endl;
-#endif // __DEBUG_H__
-                } // if
-            } // if
-        } else {                                        // obtain input and possibly output files
-            if ( cpp_in == NULL ) {
-                cpp_in = argv[i];
-#ifdef __DEBUG_H__
-                cerr << "cpp_in:\"" << cpp_in << "\"" << endl;
-#endif // __DEBUG_H__
-            } else if ( cpp_out == NULL ) {
-                cpp_out = argv[i];
-#ifdef __DEBUG_H__
-                cerr << "cpp_out:\"" << cpp_out << "\""<< endl;
-#endif // __DEBUG_H__
-            } else {
-                cerr << "Usage: " << argv[0] << " input-file [output-file] [options]" << endl;
-                exit( EXIT_FAILURE );
-            } // if
-        } // if
-    } // for
-#ifdef __DEBUG_H__
-    cerr << "args:";
-    for ( i = 1; i < nargs; i += 1 ) {
-        cerr << " " << args[i];
-    } // for
-    if ( cpp_in != NULL ) cerr << " " << cpp_in;
-    if ( cpp_out != NULL ) cerr << " " << cpp_out;
-    cerr << endl;
-#endif // __DEBUG_H__
-    if ( cpp_in == NULL ) {
-        cerr << "Usage: " << argv[0] << " input-file [output-file] [options]" << endl;
-        exit( EXIT_FAILURE );
-    } // if
-    if ( cpp_flag ) {
-        // The -E flag is specified on the cfa command so only run the preprocessor and output is written to standard
-        // output or -o. The call to cfa has a -E so it does not have to be added to the argument list.
-        args[0] = compiler_name.c_str();
         args[nargs] = cpp_in;
         nargs += 1;
+        if ( o_name != NULL ) {                         // location for output
+            args[nargs] = "-o";
+            nargs += 1;
+            args[nargs] = o_name;
+            nargs += 1;
+        } // if
+        args[nargs] = NULL;                             // terminate argument list
+#ifdef __DEBUG_H__
+        cerr << "nargs: " << nargs << endl;
+        args[nargs] = NULL;                                                                     // terminate argument list
+#ifdef __DEBUG_H__
+        cerr << "stage2 nargs: " << nargs << endl;
         for ( i = 0; args[i] != NULL; i += 1 ) {
             cerr << args[i] << " ";
+                cerr << args[i] << " ";
         } // for
         cerr << endl;
 #endif // __DEBUG_H__
         execvp( args[0], (char *const *)args );         // should not return
+        execvp( args[0], (char * const *)args );                        // should not return
         perror( "CFA Translator error: cpp level, execvp" );
+        exit( EXIT_FAILURE );
+    } // if
+    // Create a temporary file to store output of the C preprocessor.
+    tmpfilefd = mkstemp( tmpname );
+    if ( tmpfilefd == -1 ) {
+        perror( "CFA Translator error: cpp level, mkstemp" );
+        exit( EXIT_FAILURE );
+    } // if
+#ifdef __DEBUG_H__
+    cerr << "tmpname:" << tmpname << " tmpfilefd:" << tmpfilefd << endl;
+#endif // __DEBUG_H__
+    // Run the C preprocessor and save the output in tmpfile.
+    if ( fork() == 0 ) {                                // child process ?
+        // -o xxx.ii cannot be used to write the output file from cpp because no output file is created if cpp detects
+        // an error (e.g., cannot find include file). Whereas, output is always generated, even when there is an error,
+        // when cpp writes to stdout. Hence, stdout is redirected into the temporary file.
+        if ( freopen( tmpname, "w", stdout ) == NULL ) { // redirect stdout to tmpname
+            perror( "CFA Translator error: cpp level, freopen" );
+            exit( EXIT_FAILURE );
+        } // if
+        args[0] = compiler_name.c_str();
+        args[nargs] = cpp_in;                           // input to cpp
+        nargs += 1;
+        args[nargs] = NULL;                             // terminate argument list
+#ifdef __DEBUG_H__
+        cerr << "cpp nargs: " << nargs << endl;
+        for ( i = 0; args[i] != NULL; i += 1 ) {
+            cerr << args[i] << " ";
+        } // for
+        cerr << endl;
+#endif // __DEBUG_H__
+        execvp( args[0], (char *const *)args );         // should not return
+        perror( "CFA Translator error: cpp level, execvp" );
+        exit( EXIT_FAILURE );
+    } // if
+    wait( &code );                                      // wait for child to finish
+#ifdef __DEBUG_H__
+    cerr << "return code from cpp:" << WEXITSTATUS(code) << endl;
+#endif // __DEBUG_H__
+    if ( WIFSIGNALED(code) != 0 ) {                     // child failed ?
+        rmtmpfile();                                    // remove tmpname
+        cerr << "CFA Translator error: cpp failed with signal " << WTERMSIG(code) << endl;
+        exit( EXIT_FAILURE );
+    } // if
+    if ( WEXITSTATUS(code) != 0 ) {                     // child error ?
+        rmtmpfile();                                    // remove tmpname
+        exit( WEXITSTATUS( code ) );                    // do not continue
+    } // if
+    // If -CFA flag specified, run the cfa-cpp preprocessor on the temporary file, and output is written to standard
+    // output.  Otherwise, run the cfa-cpp preprocessor on the temporary file and save the result into the output file.
+    if ( fork() == 0 ) {                                // child runs CFA
+        uargs[0] = ( *new string( bprefix + "/cfa-cpp" ) ).c_str();
+        uargs[nuargs] = "-p";
+        nuargs += 1;
+        uargs[nuargs] = tmpname;
+        nuargs += 1;
+        if ( o_name != NULL ) {
+            uargs[nuargs] = o_name;
+            nuargs += 1;
+        } else if ( ! CFA_flag ) {                      // run cfa-cpp ?
+            uargs[nuargs] = cpp_out;
+            nuargs += 1;
+        } // if
+        uargs[nuargs] = NULL;                           // terminate argument list
+#ifdef __DEBUG_H__
+        cerr << "cfa-cpp nuargs: " << o_name << " " << CFA_flag << " " << nuargs << endl;
+        for ( i = 0; uargs[i] != NULL; i += 1 ) {
+            cerr << uargs[i] << " ";
+        } // for
+        cerr << endl;
+#endif // __DEBUG_H__
+        execvp( uargs[0], (char * const *)uargs );      // should not return
+        perror( "CFA Translator error: cpp level, execvp" );
+        exit( EXIT_FAILURE );
+    } // if
+    wait( &code );                                      // wait for child to finish
+#ifdef __DEBUG_H__
+    cerr << "return code from cfa-cpp:" << WEXITSTATUS(code) << endl;
+#endif // __DEBUG_H__
+    // Must unlink here because file must exist across execvp.
+    rmtmpfile();                                        // remove tmpname
+    if ( WIFSIGNALED(code) ) {                          // child failed ?
+        cerr << "CFA Translator error: cfa-cpp failed with signal " << WTERMSIG(code) << endl;
+        exit( EXIT_FAILURE );
+    } // if
+    exit( WEXITSTATUS(code) );
+} // Stage1
+void Stage2( const int argc, const char * const * argv ) {
+    int i;
+    string arg;
+    const char *cpp_in = NULL;
+    const char *args[argc + 100];                       // leave space for 100 additional cfa command line values
+    int nargs = 1;                                      // number of arguments in args list; 0 => command name
+    // process all the arguments
+    checkEnv( args, nargs );                            // arguments passed via environment variables
+    for ( i = 1; i < argc; i += 1 ) {
+#ifdef __DEBUG_H__
+        cerr << "argv[" << i << "]:\"" << argv[i] << "\"" << endl;
+#endif // __DEBUG_H__
+        arg = argv[i];
+#ifdef __DEBUG_H__
+        cerr << "arg:\"" << arg << "\"" << endl;
+#endif // __DEBUG_H__
+        if ( prefix( arg, "-" ) ) {
+            // strip inappropriate flags
+            if ( arg == "-quiet" || arg == "-version" || arg == "-fpreprocessed" ||
+                 // Currently CFA does not suppose precompiled .h files.
+                 prefix( arg, "--output-pch" ) ) {
+            // strip inappropriate flags with an argument
+            } else if ( arg == "-auxbase" || arg == "-auxbase-strip" || arg == "-dumpbase" ) {
+                i += 1;
+#ifdef __DEBUG_H__
+                cerr << "arg:\"" << argv[i] << "\"" << endl;
+#endif // __DEBUG_H__
+            // all other flags
+            } else {
+                args[nargs] = argv[i];                  // pass the flag along
+                nargs += 1;
+                if ( arg == "-o" ) {
+                    i += 1;
+                    args[nargs] = argv[i];              // pass the argument along
+                    nargs += 1;
+#ifdef __DEBUG_H__
+                    cerr << "arg:\"" << argv[i] << "\"" << endl;
+#endif // __DEBUG_H__
+                } // if
+            } // if
+        } else {                                        // obtain input and possibly output files
+            if ( cpp_in == NULL ) {
+                cpp_in = argv[i];
+#ifdef __DEBUG_H__
+                cerr << "cpp_in:\"" << cpp_in << "\"" << endl;
+#endif // __DEBUG_H__
+            } else {
+        exit( EXIT_FAILURE );                                                           // tell gcc not to go any further
+} // Stage2
+int main( const int argc, const char * const argv[], const char * const env[] ) {
+#ifdef __DEBUG_H__
+        for ( int i = 0; env[i] != NULL; i += 1 ) {
+                cerr << env[i] << endl;
+        } // for
+#endif // __DEBUG_H__
+        string arg = argv[1];
+        // Currently, stage 1 starts with flag -E and stage 2 with flag -fpreprocessed.
+        if ( arg == "-E" ) {
+#ifdef __DEBUG_H__
+                cerr << "Stage1" << endl;
+#endif // __DEBUG_H__
+                Stage1( argc, argv );
+        } else if ( arg == "-fpreprocessed" ) {
+#ifdef __DEBUG_H__
+                cerr << "Stage2" << endl;
+#endif // __DEBUG_H__
+                Stage2( argc, argv );
+        } else {
                 cerr << "Usage: " << argv[0] << " input-file [output-file] [options]" << endl;
                 exit( EXIT_FAILURE );
+            } // if
+        } // if
+    } // for
+#ifdef __DEBUG_H__
+    cerr << "args:";
+    for ( i = 1; i < nargs; i += 1 ) {
+        cerr << " " << args[i];
+    } // for
+    cerr << endl;
+    if ( cpp_in != NULL ) cerr << " " << cpp_in;
+#endif // __DEBUG_H__
+    args[0] = compiler_name.c_str();
+    args[nargs] = "-S";                                 // only compile and put assembler output in specified file
+    nargs += 1;
+    args[nargs] = cpp_in;
+    nargs += 1;
+    args[nargs] = NULL;                                 // terminate argument list
+#ifdef __DEBUG_H__
+    cerr << "stage2 nargs: " << nargs << endl;
+    for ( i = 0; args[i] != NULL; i += 1 ) {
+        cerr << args[i] << " ";
+    } // for
+    cerr << endl;
+#endif // __DEBUG_H__
+    execvp( args[0], (char * const *)args );            // should not return
+    perror( "CFA Translator error: cpp level, execvp" );
+    exit( EXIT_FAILURE );                               // tell gcc not to go any further
+} // Stage2
+int main( const int argc, const char * const argv[], const char * const env[] ) {
+#ifdef __DEBUG_H__
+    for ( int i = 0; env[i] != NULL; i += 1 ) {
+        cerr << env[i] << endl;
+    } // for
+#endif // __DEBUG_H__
+    string arg = argv[1];
+    // Currently, stage 1 starts with flag -E and stage 2 with flag -fpreprocessed.
+    if ( arg == "-E" ) {
+#ifdef __DEBUG_H__
+        cerr << "Stage1" << endl;
+#endif // __DEBUG_H__
+        Stage1( argc, argv );
+    } else if ( arg == "-fpreprocessed" ) {
+#ifdef __DEBUG_H__
+        cerr << "Stage2" << endl;
+#endif // __DEBUG_H__
+        Stage2( argc, argv );
+    } else {
+        cerr << "Usage: " << argv[0] << " input-file [output-file] [options]" << endl;
+        exit( EXIT_FAILURE );
+    } // if
+        } // if
 } // main
 // Local Variables: //
+// tab-width: 4 //
+// mode: c++ //
 // compile-command: "make install" //
 // End: //

driver/cfa.cc

-                      rb8508a2
+                      rb87a5ed
+//                              -*- Mode: C++ -*-
+//
+// CForall Version 1.0, Copyright (C) Peter A. Buhr 2002
+//
+//
+// 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.
+//
 // cfa.cc --
 //
+//
 // Author           : Peter A. Buhr
 // Created On       : Tue Aug 20 13:44:49 2002
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri May 15 15:01:26 2015
 // Update Count     : 108
 //
+// Last Modified On : Sat May 16 07:47:05 2015
+// Update Count     : 111
+//
 #include <iostream>
 #include <cstdio>                                       // perror
 #include <cstdlib>                                      // putenv, exit
 #include <unistd.h>                                     // execvp
 #include <string>                                       // STL version
 #include "config.h"                                     // configure info
+#include <cstdio>                                                                               // perror
+#include <cstdlib>                                                                              // putenv, exit
+#include <unistd.h>                                                                             // execvp
+#include <string>                                                                               // STL version
+#include "config.h"                                                                             // configure info
 using std::cerr;
 …
 bool prefix( string arg, string pre ) {
     return arg.substr( 0, pre.size() ) == pre;
+        return arg.substr( 0, pre.size() ) == pre;
 } // prefix
 void shuffle( const char *args[], int S, int E, int N ) {
     // S & E index 1 passed the end so adjust with -1
 #ifdef __DEBUG_H__
     cerr << "shuffle:" << S << " " << E << " " << N << endl;
 #endif // __DEBUG_H__
     for ( int j = E-1 + N; j > S-1 + N; j -=1 ) {
 #ifdef __DEBUG_H__
         cerr << "\t" << j << " " << j-N << endl;
 #endif // __DEBUG_H__
         args[j] = args[j-N];
     } // for
+        // S & E index 1 passed the end so adjust with -1
+#ifdef __DEBUG_H__
+        cerr << "shuffle:" << S << " " << E << " " << N << endl;
+#endif // __DEBUG_H__
+        for ( int j = E-1 + N; j > S-1 + N; j -=1 ) {
+#ifdef __DEBUG_H__
+                cerr << "\t" << j << " " << j-N << endl;
+#endif // __DEBUG_H__
+                args[j] = args[j-N];
+        } // for
 } // shuffle
 int main( int argc, char *argv[] ) {
+    string Version( VERSION );                          // current version number from CONFIG
+    string Major( "0" ), Minor( "0" ), Patch( "0" );    // default version numbers
+    int posn1 = Version.find( "." );                    // find the divider between major and minor version numbers
+    if ( posn1 == -1 ) {                                // not there ?
+        Major = Version;
+    } else {
+        Major = Version.substr( 0, posn1 );
+        int posn2 = Version.find( ".", posn1 + 1 );     // find the divider between minor and patch numbers
+        if ( posn2 == -1 ) {                            // not there ?
+            Minor = Version.substr( posn1 );
+        string Version( VERSION );                                                      // current version number from CONFIG
+        string Major( "0" ), Minor( "0" ), Patch( "0" );        // default version numbers
+        int posn1 = Version.find( "." );                                        // find the divider between major and minor version numbers
+        if ( posn1 == -1 ) {                                                            // not there ?
+                Major = Version;
         } else {
+            Minor = Version.substr( posn1 + 1, posn2 - posn1 - 1 );
+            Patch = Version.substr( posn2 + 1 );
+        } // if
+    } // if
+    string installincdir( CFA_INCDIR );                 // fixed location of cc1 and cfa-cpp commands
+    string installlibdir( CFA_LIBDIR );                 // fixed location of include files
+    string heading;                                     // banner printed at start of cfa compilation
+    string arg;                                         // current command-line argument during command-line parsing
+    string Bprefix;                                     // path where gcc looks for compiler command steps
+    string langstd;                                     // language standard
+    string compiler_path( GCC_PATH );                   // path/name of C compiler
+    string compiler_name;                               // name of C compiler
+    bool nonoptarg = false;                             // indicates non-option argument specified
+    bool link = true;                                   // linking as well as compiling
+    bool verbose = false;                               // -v flag
+    bool quiet = false;                                 // -quiet flag
+    bool debug = true;                                  // -debug flag
+    bool help = false;                                  // -help flag
+    bool CFA_flag = false;                              // -CFA flag
+    bool cpp_flag = false;                              // -E or -M flag, preprocessor only
+    bool debugging = false;                             // -g flag
+    const char *args[argc + 100];                       // cfa command line values, plus some space for additional flags
+    int sargs = 1;                                      // starting location for arguments in args list
+    int nargs = sargs;                                  // number of arguments in args list; 0 => command name
+    const char *libs[argc + 20];                        // non-user libraries must come separately, plus some added libraries and flags
+    int nlibs = 0;
+#ifdef __DEBUG_H__
+    cerr << "CFA:" << endl;
+#endif // __DEBUG_H__
+    // process command-line arguments
+    for ( int i = 1; i < argc; i += 1 ) {
+#ifdef __DEBUG_H__
+        cerr << "argv[" << i << "]:\"" << argv[i] << "\"" << endl;
+#endif // __DEBUG_H__
+        arg = argv[i];                                  // convert to string value
+#ifdef __DEBUG_H__
+        cerr << "arg:\"" << arg << "\"" << endl;
+#endif // __DEBUG_H__
+        if ( prefix( arg, "-" ) ) {
+            // pass through arguments
+            if ( arg == "-Xlinker" || arg == "-o" ) {
+                args[nargs] = argv[i];                  // pass the argument along
+                nargs += 1;
+                i += 1;
+                if ( i == argc ) continue;              // next argument available ?
+                args[nargs] = argv[i];                  // pass the argument along
+                nargs += 1;
+            } else if ( arg == "-XCFA" ) {              // CFA pass through
+                i += 1;
+                args[nargs] = ( *new string( string("-D__CFA_FLAG__=") + argv[i] ) ).c_str();
+                nargs += 1;
+            // CFA specific arguments
+            } else if ( arg == "-CFA" ) {
+                CFA_flag = true;                        // strip the -CFA flag
+                link = false;
+                args[nargs] = "-E";                     // replace the argument with -E
+                nargs += 1;
+            } else if ( arg == "-debug" ) {
+                debug = true;                           // strip the debug flag
+            } else if ( arg == "-nodebug" ) {
+                debug = false;                          // strip the nodebug flag
+            } else if ( arg == "-quiet" ) {
+                quiet = true;                           // strip the quiet flag
+            } else if ( arg == "-noquiet" ) {
+                quiet = false;                          // strip the noquiet flag
+            } else if ( arg == "-help" ) {
+                help = true;                            // strip the help flag
+            } else if ( arg == "-nohelp" ) {
+                help = false;                           // strip the nohelp flag
+            } else if ( arg == "-compiler" ) {
+                // use the user specified compiler
+                i += 1;
+                if ( i == argc ) continue;              // next argument available ?
+                compiler_path = argv[i];
+                if ( putenv( (char *)( *new string( string( "__U_COMPILER__=" ) + argv[i]) ).c_str() ) != 0 ) {
+                    cerr << argv[0] << " error, cannot set environment variable." << endl;
+                    exit( EXIT_FAILURE );
+                Major = Version.substr( 0, posn1 );
+                int posn2 = Version.find( ".", posn1 + 1 );             // find the divider between minor and patch numbers
+                if ( posn2 == -1 ) {                                                    // not there ?
+                        Minor = Version.substr( posn1 );
+                } else {
+                        Minor = Version.substr( posn1 + 1, posn2 - posn1 - 1 );
+                        Patch = Version.substr( posn2 + 1 );
                 } // if
+            // C++ specific arguments
+            } else if ( arg == "-v" ) {
+                verbose = true;                         // verbosity required
+                args[nargs] = argv[i];                  // pass the argument along
+                nargs += 1;
+            } else if ( arg == "-g" ) {
+                debugging = true;                       // symbolic debugging required
+                args[nargs] = argv[i];                  // pass the argument along
+                nargs += 1;
+            } else if ( prefix( arg, "-B" ) ) {
+                Bprefix = arg.substr(2);                // strip the -B flag
+        } // if
+        string installincdir( CFA_INCDIR );                                     // fixed location of cc1 and cfa-cpp commands
+        string installlibdir( CFA_LIBDIR );                                     // fixed location of include files
+        string heading;                                                                         // banner printed at start of cfa compilation
+        string arg;                                                                                     // current command-line argument during command-line parsing
+        string Bprefix;                                                                         // path where gcc looks for compiler command steps
+        string langstd;                                                                         // language standard
+        string compiler_path( GCC_PATH );                                       // path/name of C compiler
+        string compiler_name;                                                           // name of C compiler
+        bool nonoptarg = false;                                                         // indicates non-option argument specified
+        bool link = true;                                                                       // linking as well as compiling
+        bool verbose = false;                                                           // -v flag
+        bool quiet = false;                                                                     // -quiet flag
+        bool debug = true;                                                                      // -debug flag
+        bool help = false;                                                                      // -help flag
+        bool CFA_flag = false;                                                          // -CFA flag
+        bool cpp_flag = false;                                                          // -E or -M flag, preprocessor only
+        bool debugging = false;                                                         // -g flag
+        const char *args[argc + 100];                                           // cfa command line values, plus some space for additional flags
+        int sargs = 1;                                                                          // starting location for arguments in args list
+        int nargs = sargs;                                                                      // number of arguments in args list; 0 => command name
+        const char *libs[argc + 20];                                            // non-user libraries must come separately, plus some added libraries and flags
+        int nlibs = 0;
+#ifdef __DEBUG_H__
+        cerr << "CFA:" << endl;
+#endif // __DEBUG_H__
+        // process command-line arguments
+        for ( int i = 1; i < argc; i += 1 ) {
+#ifdef __DEBUG_H__
+                cerr << "argv[" << i << "]:\"" << argv[i] << "\"" << endl;
+#endif // __DEBUG_H__
+                arg = argv[i];                                                                  // convert to string value
+#ifdef __DEBUG_H__
+                cerr << "arg:\"" << arg << "\"" << endl;
+#endif // __DEBUG_H__
+                if ( prefix( arg, "-" ) ) {
+                        // pass through arguments
+                        if ( arg == "-Xlinker" || arg == "-o" ) {
+                                args[nargs] = argv[i];                                  // pass the argument along
+                                nargs += 1;
+                                i += 1;
+                                if ( i == argc ) continue;                              // next argument available ?
+                                args[nargs] = argv[i];                                  // pass the argument along
+                                nargs += 1;
+                        } else if ( arg == "-XCFA" ) {                          // CFA pass through
+                                i += 1;
+                                args[nargs] = ( *new string( string("-D__CFA_FLAG__=") + argv[i] ) ).c_str();
+                                nargs += 1;
+                                // CFA specific arguments
+                        } else if ( arg == "-CFA" ) {
+                                CFA_flag = true;                                                // strip the -CFA flag
+                                link = false;
+                                args[nargs] = "-E";                                             // replace the argument with -E
+                                nargs += 1;
+                        } else if ( arg == "-debug" ) {
+                                debug = true;                                                   // strip the debug flag
+                        } else if ( arg == "-nodebug" ) {
+                                debug = false;                                                  // strip the nodebug flag
+                        } else if ( arg == "-quiet" ) {
+                                quiet = true;                                                   // strip the quiet flag
+                        } else if ( arg == "-noquiet" ) {
+                                quiet = false;                                                  // strip the noquiet flag
+                        } else if ( arg == "-help" ) {
+                                help = true;                                                    // strip the help flag
+                        } else if ( arg == "-nohelp" ) {
+                                help = false;                                                   // strip the nohelp flag
+                        } else if ( arg == "-compiler" ) {
+                                // use the user specified compiler
+                                i += 1;
+                                if ( i == argc ) continue;                              // next argument available ?
+                                compiler_path = argv[i];
+                                if ( putenv( (char *)( *new string( string( "__U_COMPILER__=" ) + argv[i]) ).c_str() ) != 0 ) {
+                                        cerr << argv[0] << " error, cannot set environment variable." << endl;
+                                        exit( EXIT_FAILURE );
+                                } // if
+                                // C++ specific arguments
+                        } else if ( arg == "-v" ) {
+                                verbose = true;                                                 // verbosity required
+                                args[nargs] = argv[i];                                  // pass the argument along
+                                nargs += 1;
+                        } else if ( arg == "-g" ) {
+                                debugging = true;                                               // symbolic debugging required
+                                args[nargs] = argv[i];                                  // pass the argument along
+                                nargs += 1;
+                        } else if ( prefix( arg, "-B" ) ) {
+                                Bprefix = arg.substr(2);                                // strip the -B flag
+                                args[nargs] = ( *new string( string("-D__GCC_BPREFIX__=") + Bprefix ) ).c_str();
+                                nargs += 1;
+                        } else if ( prefix( arg, "-b" ) ) {
+                                if ( arg.length() == 2 ) {                              // separate argument ?
+                                        i += 1;
+                                        if ( i == argc ) continue;                      // next argument available ?
+                                        arg += argv[i];                                         // concatenate argument
+                                } // if
+                                // later versions of gcc require the -b option to appear at the start of the command line
+                                shuffle( args, sargs, nargs, 1 );               // make room at front of argument list
+                                args[sargs] = ( *new string( arg ) ).c_str(); // pass the argument along
+                                if ( putenv( (char *)( *new string( string( "__GCC_MACHINE__=" ) + arg ) ).c_str() ) != 0 ) {
+                                        cerr << argv[0] << " error, cannot set environment variable." << endl;
+                                        exit( EXIT_FAILURE );
+                                } // if
+                                sargs += 1;
+                                nargs += 1;
+                        } else if ( prefix( arg, "-V" ) ) {
+                                if ( arg.length() == 2 ) {                              // separate argument ?
+                                        i += 1;
+                                        if ( i == argc ) continue;                      // next argument available ?
+                                        arg += argv[i];                                         // concatenate argument
+                                } // if
+                                // later versions of gcc require the -V option to appear at the start of the command line
+                                shuffle( args, sargs, nargs, 1 );               // make room at front of argument list
+                                args[sargs] = ( *new string( arg ) ).c_str(); // pass the argument along
+                                if ( putenv( (char *)( *new string( string( "__GCC_VERSION__=" ) + arg ) ).c_str() ) != 0 ) {
+                                        cerr << argv[0] << " error, cannot set environment variable." << endl;
+                                        exit( EXIT_FAILURE );
+                                } // if
+                                sargs += 1;
+                                nargs += 1;
+                        } else if ( arg == "-c" || arg == "-S" || arg == "-E" || arg == "-M" || arg == "-MM" ) {
+                                args[nargs] = argv[i];                                  // pass the argument along
+                                nargs += 1;
+                                if ( arg == "-E" || arg == "-M" || arg == "-MM" ) {
+                                        cpp_flag = true;                                        // cpp only
+                                } // if
+                                link = false;                           // no linkage required
+                        } else if ( arg[1] == 'l' ) {
+                                // if the user specifies a library, load it after user code
+                                libs[nlibs] = argv[i];
+                                nlibs += 1;
+                        } else {
+                                // concatenate any other arguments
+                                args[nargs] = argv[i];
+                                nargs += 1;
+                        } // if
+                } else {
+                        // concatenate other arguments
+                        args[nargs] = argv[i];
+                        nargs += 1;
+                        nonoptarg = true;
+                } // if
+        } // for
+#ifdef __DEBUG_H__
+        cerr << "args:";
+        for ( int i = 1; i < nargs; i += 1 ) {
+                cerr << " " << args[i];
+        } // for
+        cerr << endl;
+#endif // __DEBUG_H__
+        if ( cpp_flag && CFA_flag ) {
+                cerr << argv[0] << " error, cannot use -E and -CFA flags together." << endl;
+                exit( EXIT_FAILURE );
+        } // if
+        string d;
+        if ( debug ) {
+                d = "-d";
+        } // if
+        args[nargs] = "-I" CFA_INCDIR;
+        nargs += 1;
+        if ( link ) {
+                // include the cfa library in case it's needed
+                args[nargs] = "-L" CFA_LIBDIR;
+                nargs += 1;
+                args[nargs] = "-lcfa";
+                nargs += 1;
+        } // if
+        // add the correct set of flags based on the type of compile this is
+        args[nargs] = ( *new string( string("-D__CFA_MAJOR__=") + Major ) ).c_str();
+        nargs += 1;
+        args[nargs] = ( *new string( string("-D__CFA_MINOR__=") + Minor ) ).c_str();
+        nargs += 1;
+        if ( cpp_flag ) {
+                args[nargs] = "-D__CPP__";
+                nargs += 1;
+        } // if
+        if ( CFA_flag ) {
+                args[nargs] = "-D__CFA__";
+                nargs += 1;
+        } // if
+        if ( debug ) {
+                heading += " (debug)";
+                args[nargs] = "-D__CFA_DEBUG__";
+                nargs += 1;
+        } else {
+                heading += " (no debug)";
+        } // if
+        if ( Bprefix.length() == 0 ) {
+                Bprefix = installlibdir;
                 args[nargs] = ( *new string( string("-D__GCC_BPREFIX__=") + Bprefix ) ).c_str();
                 nargs += 1;
+            } else if ( prefix( arg, "-b" ) ) {
+                if ( arg.length() == 2 ) {              // separate argument ?
+                    i += 1;
+                    if ( i == argc ) continue;          // next argument available ?
+                    arg += argv[i];                     // concatenate argument
+        } // if
+        // execute the compilation command
+        args[0] = compiler_path.c_str();                                        // set compiler command for exec
+        // find actual name of the compiler independent of the path to it
+        int p = compiler_path.find_last_of( '/' );                      // scan r -> l for first '/'
+        if ( p == -1 ) {
+                compiler_name = compiler_path;
+        } else {
+                compiler_name = *new string( compiler_path.substr( p + 1 ) );
+        } // if
+        if ( prefix( compiler_name, "gcc" ) ) {                         // allow suffix on gcc name
+                args[nargs] = "-no-integrated-cpp";
+                nargs += 1;
+                args[nargs] = "-Wno-deprecated";
+                nargs += 1;
+                args[nargs] = "-std=c99";
+                nargs += 1;
+                args[nargs] = ( *new string( string("-B") + Bprefix + "/" ) ).c_str();
+                nargs += 1;
+        } else {
+                cerr << argv[0] << " error, compiler " << compiler_name << " not supported." << endl;
+                exit( EXIT_FAILURE );
+        } // if
+        for ( int i = 0; i < nlibs; i += 1 ) {                          // copy non-user libraries after all user libraries
+                args[nargs] = libs[i];
+                nargs += 1;
+        } // for
+        args[nargs] = NULL;                                                                     // terminate with NULL
+#ifdef __DEBUG_H__
+        cerr << "nargs: " << nargs << endl;
+        cerr << "args:" << endl;
+        for ( int i = 0; args[i] != NULL; i += 1 ) {
+                cerr << " \"" << args[i] << "\"" << endl;
+        } // for
+#endif // __DEBUG_H__
+        if ( ! quiet ) {
+                cerr << "CFA " << "Version " << Version << heading << endl;
+                if ( help ) {
+                        cerr <<
+                                "-debug\t\t\t: use cfa runtime with debug checking" << endl <<
+                                "-help\t\t\t: print this help message" << endl <<
+                                "-quiet\t\t\t: print no messages from the cfa command" << endl <<
+                                "-CFA\t\t\t: run the cpp preprocessor and the cfa-cpp translator" << endl <<
+                                "-XCFA -cfa-cpp-flag\t: pass next flag as-is to the cfa-cpp translator" << endl <<
+                                "...\t\t\t: any other " << compiler_name << " flags" << endl;
                 } // if
+                // later versions of gcc require the -b option to appear at the start of the command line
+                shuffle( args, sargs, nargs, 1 );       // make room at front of argument list
+                args[sargs] = ( *new string( arg ) ).c_str(); // pass the argument along
+                if ( putenv( (char *)( *new string( string( "__GCC_MACHINE__=" ) + arg ) ).c_str() ) != 0 ) {
+                    cerr << argv[0] << " error, cannot set environment variable." << endl;
+                    exit( EXIT_FAILURE );
+                } // if
+                sargs += 1;
+                nargs += 1;
+            } else if ( prefix( arg, "-V" ) ) {
+                if ( arg.length() == 2 ) {              // separate argument ?
+                    i += 1;
+                    if ( i == argc ) continue;          // next argument available ?
+                    arg += argv[i];                     // concatenate argument
+                } // if
+                // later versions of gcc require the -V option to appear at the start of the command line
+                shuffle( args, sargs, nargs, 1 );       // make room at front of argument list
+                args[sargs] = ( *new string( arg ) ).c_str(); // pass the argument along
+                if ( putenv( (char *)( *new string( string( "__GCC_VERSION__=" ) + arg ) ).c_str() ) != 0 ) {
+                    cerr << argv[0] << " error, cannot set environment variable." << endl;
+                    exit( EXIT_FAILURE );
+                } // if
+                sargs += 1;
+                nargs += 1;
+            } else if ( arg == "-c" || arg == "-S" || arg == "-E" || arg == "-M" || arg == "-MM" ) {
+                args[nargs] = argv[i];                  // pass the argument along
+                nargs += 1;
+                if ( arg == "-E" || arg == "-M" || arg == "-MM" ) {
+                    cpp_flag = true;                    // cpp only
+                } // if
+                link = false;                           // no linkage required
+            } else if ( arg[1] == 'l' ) {
+                // if the user specifies a library, load it after user code
+                libs[nlibs] = argv[i];
+                nlibs += 1;
+            } else {
+                // concatenate any other arguments
+                args[nargs] = argv[i];
+                nargs += 1;
+            } // if
+        } else {
+            // concatenate other arguments
+            args[nargs] = argv[i];
+            nargs += 1;
+            nonoptarg = true;
+        } // if
+    } // for
+#ifdef __DEBUG_H__
+    cerr << "args:";
+    for ( int i = 1; i < nargs; i += 1 ) {
+        cerr << " " << args[i];
+    } // for
+    cerr << endl;
+#endif // __DEBUG_H__
+    if ( cpp_flag && CFA_flag ) {
+        cerr << argv[0] << " error, cannot use -E and -CFA flags together." << endl;
+        } // if
+        if ( verbose ) {
+                if ( argc == 2 ) exit( EXIT_SUCCESS );                  // if only the -v flag is specified, do not invoke gcc
+                for ( int i = 0; args[i] != NULL; i += 1 ) {
+                        cerr << args[i] << " ";
+                } // for
+                cerr << endl;
+        } // if
+        if ( ! nonoptarg ) {
+                cerr << argv[0] << " error, no input files" << endl;
+                exit( EXIT_FAILURE );
+        } // if
+        // execute the command and return the result
+        execvp( args[0], (char *const *)args );                         // should not return
+        perror( "CFA Translator error: cfa level, execvp" );
         exit( EXIT_FAILURE );
-    } // if
-    string d;
-    if ( debug ) {
-        d = "-d";
-    } // if
-    args[nargs] = "-I" CFA_INCDIR;
-    nargs += 1;
-    if ( link ) {
-        // include the cfa library in case it's needed
-        args[nargs] = "-L" CFA_LIBDIR;
-        nargs += 1;
-        args[nargs] = "-lcfa";
-        nargs += 1;
-    } // if
-    // add the correct set of flags based on the type of compile this is
-    args[nargs] = ( *new string( string("-D__CFA_MAJOR__=") + Major ) ).c_str();
-    nargs += 1;
-    args[nargs] = ( *new string( string("-D__CFA_MINOR__=") + Minor ) ).c_str();
-    nargs += 1;
-    if ( cpp_flag ) {
-        args[nargs] = "-D__CPP__";
-        nargs += 1;
-    } // if
-    if ( CFA_flag ) {
-        args[nargs] = "-D__CFA__";
-        nargs += 1;
-    } // if
-    if ( debug ) {
-        heading += " (debug)";
-        args[nargs] = "-D__CFA_DEBUG__";
-        nargs += 1;
-    } else {
-        heading += " (no debug)";
-    } // if
-    if ( Bprefix.length() == 0 ) {
-        Bprefix = installlibdir;
-        args[nargs] = ( *new string( string("-D__GCC_BPREFIX__=") + Bprefix ) ).c_str();
-        nargs += 1;
-    } // if
-    // execute the compilation command
-    args[0] = compiler_path.c_str();                    // set compiler command for exec
-    // find actual name of the compiler independent of the path to it
-    int p = compiler_path.find_last_of( '/' );          // scan r -> l for first '/'
-    if ( p == -1 ) {
-        compiler_name = compiler_path;
-    } else {
-        compiler_name = *new string( compiler_path.substr( p + 1 ) );
-    } // if
-    if ( prefix( compiler_name, "gcc" ) ) {             // allow suffix on gcc name
-        args[nargs] = "-no-integrated-cpp";
-        nargs += 1;
-        args[nargs] = "-Wno-deprecated";
-        nargs += 1;
-        args[nargs] = "-std=c99";
-        nargs += 1;
-        args[nargs] = ( *new string( string("-B") + Bprefix + "/" ) ).c_str();
-        nargs += 1;
-    } else {
-        cerr << argv[0] << " error, compiler " << compiler_name << " not supported." << endl;
-        exit( EXIT_FAILURE );
-    } // if
-    for ( int i = 0; i < nlibs; i += 1 ) {              // copy non-user libraries after all user libraries
-        args[nargs] = libs[i];
-        nargs += 1;
-    } // for
-    args[nargs] = NULL;                                 // terminate with NULL
-#ifdef __DEBUG_H__
-    cerr << "nargs: " << nargs << endl;
-    cerr << "args:" << endl;
-    for ( int i = 0; args[i] != NULL; i += 1 ) {
-        cerr << " \"" << args[i] << "\"" << endl;
-    } // for
-#endif // __DEBUG_H__
-    if ( ! quiet ) {
-        cerr << "CFA " << "Version " << Version << heading << endl;
-        if ( help ) {
-            cerr <<
-                "-debug\t\t\t: use cfa runtime with debug checking" << endl <<
-                "-help\t\t\t: print this help message" << endl <<
-                "-quiet\t\t\t: print no messages from the cfa command" << endl <<
-                "-CFA\t\t\t: run the cpp preprocessor and the cfa-cpp translator" << endl <<
-                "-XCFA -cfa-cpp-flag\t: pass next flag as-is to the cfa-cpp translator" << endl <<
-                "...\t\t\t: any other " << compiler_name << " flags" << endl;
-        } // if
-    } // if
-    if ( verbose ) {
-        if ( argc == 2 ) exit( EXIT_SUCCESS );          // if only the -v flag is specified, do not invoke gcc
-        for ( int i = 0; args[i] != NULL; i += 1 ) {
-            cerr << args[i] << " ";
-        } // for
-        cerr << endl;
-    } // if
-    if ( ! nonoptarg ) {
-        cerr << argv[0] << " error, no input files" << endl;
-        exit( EXIT_FAILURE );
-    } // if
-    // execute the command and return the result
-    execvp( args[0], (char *const *)args );             // should not return
-    perror( "CFA Translator error: cfa level, execvp" );
-    exit( EXIT_FAILURE );
 } // main
 // Local Variables: //
+// tab-width: 4 //
+// mode: c++ //
 // compile-command: "make install" //
 // End: //

include/bfd.h

-                      rb8508a2
+                      rb87a5ed
+//                              -*- Mode: C++ -*-
+//
+// Cforall Version 1.0.0, Copyright (C) Peter A. Buhr 2015
+//
+//
+// 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.
+//
 // bfd.h --
 //
+//
 // Author           : Peter A. Buhr
 // Created On       : Thu Jan  8 15:50:56 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jan 10 14:12:35 2015
 // Update Count     : 3
+// Last Modified On : Sat May 16 07:54:59 2015
+// Update Count     : 5
 // This include file uses the CFA keyword "type" as a field name of a structure.
 …
 // Local Variables: //
+// tab-width: 4 //
+// mode: c++ //
 // compile-command: "make install" //
 // End: //

include/math.h

-                      rb8508a2
+                      rb87a5ed
+//                              -*- Mode: C++ -*-
+//
+// Cforall Version 1.0.0, Copyright (C) Peter A. Buhr 2014
+//
+//
+// 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.
+//
 // math.h --
 //
+//
 // Author           : Peter A. Buhr
 // Created On       : Mon Nov 10 23:41:29 2014
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jan 10 14:12:21 2015
 // Update Count     : 2
+// Last Modified On : Sat May 16 07:55:52 2015
+// Update Count     : 3
 // This include file uses the CFA keyword "type" as a field name of a structure.
 …
 // Local Variables: //
+// tab-width: 4 //
+// mode: c++ //
 // compile-command: "make install" //
 // End: //

libcfa/Makefile.in

-                      rb8508a2
+                      rb87a5ed
+######################### -*- Mode: Makefile-Gmake -*- ########################
+##
+## 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.
+##
+## Makefile.in --
+##
+## Author           : Peter A. Buhr
+## Created On       : Sat May 16 08:05:18 2015
+## Last Modified By : Peter A. Buhr
+## Last Modified On : Sat May 16 08:06:05 2015
+## Update Count     : 1
+###############################################################################
 INSTALL=@INSTALL@
 BACKEND_CC := @BACKEND_CC@

libcfa/prototypes.awk

-                      rb8508a2
+                      rb87a5ed
+#
+# 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.
+#
+# prototypes.awk --
+#
+# Author           : Peter A. Buhr
+# Created On       : Sat May 16 07:57:37 2015
+# Last Modified By : Peter A. Buhr
+# Last Modified On : Sat May 16 08:02:10 2015
+# Update Count     : 3
+#
 # http://llvm.org/svn/llvm-project/cfe/trunk/include/clang/Basic/Builtins.def
 …
     FS = "("
     # order so string search is longest string
     types[0]  = "UINTMAX";                      vtypes[0]  = "unsigned long int"
     types[1]  = "UINT16";                       vtypes[1]  = "short int"
     types[2]  = "UINT32";                       vtypes[2]  = "int"
     types[3]  = "UINT64";                       vtypes[3]  = "long long int"
     types[4]  = "UINT";                         vtypes[4]  = "unsigned int"
     types[5]  = "INTMAX";                       vtypes[5]  = "long int"
     types[6]  = "INTPTR";                       vtypes[6]  = "int *"
     types[7]  = "WINT";                         vtypes[7]  = "unsigned int"
     types[8]  = "INT";                          vtypes[8]  = "int"
     types[9]  = "ULONGLONG";                    vtypes[9]  = "unsigned long long"
     types[10] = "ULONG";                        vtypes[10] = "unsigned long"
     types[11] = "UNSIGNED";                     vtypes[11] = "unsigned"
+    types[0]  = "UINTMAX";                                      vtypes[0]  = "unsigned long int"
+    types[1]  = "UINT16";                                       vtypes[1]  = "short int"
+    types[2]  = "UINT32";                                       vtypes[2]  = "int"
+    types[3]  = "UINT64";                                       vtypes[3]  = "long long int"
+    types[4]  = "UINT";                                         vtypes[4]  = "unsigned int"
+    types[5]  = "INTMAX";                                       vtypes[5]  = "long int"
+    types[6]  = "INTPTR";                                       vtypes[6]  = "int *"
+    types[7]  = "WINT";                                         vtypes[7]  = "unsigned int"
+    types[8]  = "INT";                                          vtypes[8]  = "int"
+    types[9]  = "ULONGLONG";                            vtypes[9]  = "unsigned long long"
+    types[10] = "ULONG";                                        vtypes[10] = "unsigned long"
+    types[11] = "UNSIGNED";                                     vtypes[11] = "unsigned"
     types[12] = "COMPLEX_LONGDOUBLE";           vtypes[12] = "_Complex long double"
     types[13] = "COMPLEX_DOUBLE";               vtypes[13] = "_Complex double"
     types[14] = "COMPLEX_FLOAT";                vtypes[14] = "_Complex float"
     types[15] = "LONGDOUBLEPTR";                vtypes[15] = "long double *"
     types[16] = "LONGDOUBLE";                   vtypes[16] = "long double"
     types[17] = "LONGLONG";                     vtypes[17] = "long long"
     types[18] = "LONG";                         vtypes[18] = "long"
     types[19] = "DFLOAT32";                     vtypes[19] = "_Decimal32"
     types[20] = "DFLOAT64";                     vtypes[20] = "_Decimal64"
     types[21] = "DFLOAT128";                    vtypes[21] = "_Decimal128"
     types[22] = "DOUBLEPTR";                    vtypes[22] = "double *"
     types[23] = "DOUBLE";                       vtypes[23] = "double"
     types[24] = "FLOATPTR";                     vtypes[24] = "float *"
     types[25] = "FLOAT";                        vtypes[25] = "float"
     types[26] = "CONST_PTR";                    vtypes[26] = "const void *"
     types[27] = "CONST_STRING";                 vtypes[27] = "const char *"
+    types[13] = "COMPLEX_DOUBLE";                       vtypes[13] = "_Complex double"
+    types[14] = "COMPLEX_FLOAT";                        vtypes[14] = "_Complex float"
+    types[15] = "LONGDOUBLEPTR";                        vtypes[15] = "long double *"
+    types[16] = "LONGDOUBLE";                           vtypes[16] = "long double"
+    types[17] = "LONGLONG";                                     vtypes[17] = "long long"
+    types[18] = "LONG";                                         vtypes[18] = "long"
+    types[19] = "DFLOAT32";                                     vtypes[19] = "_Decimal32"
+    types[20] = "DFLOAT64";                                     vtypes[20] = "_Decimal64"
+    types[21] = "DFLOAT128";                            vtypes[21] = "_Decimal128"
+    types[22] = "DOUBLEPTR";                            vtypes[22] = "double *"
+    types[23] = "DOUBLE";                                       vtypes[23] = "double"
+    types[24] = "FLOATPTR";                                     vtypes[24] = "float *"
+    types[25] = "FLOAT";                                        vtypes[25] = "float"
+    types[26] = "CONST_PTR";                            vtypes[26] = "const void *"
+    types[27] = "CONST_STRING";                         vtypes[27] = "const char *"
     types[28] = "PTR_FN_VOID_VAR_PTR_SIZE";     vtypes[28] = ""
     types[29] = "PTR_CONST_STRING";             vtypes[29] = "char *const"
     types[30] = "PTRMODE_PTR";                  vtypes[30] = ""
     types[31] = "PTRPTR";                       vtypes[31] = "void **"
     types[32] = "PTR";                          vtypes[32] = "void *"
     types[33] = "VOID";                         vtypes[33] = "void"
     types[34] = "STRING";                       vtypes[34] = "char *"
     types[35] = "FILEPTR";                      vtypes[35] = "struct _IO_FILE *"
     types[36] = "SIZE";                         vtypes[36] = "unsigned long"
     types[37] = "VAR";                          vtypes[37] = "..."
     types[38] = "VALIST_ARG";                   vtypes[38] = "void **"
     types[39] = "VALIST_REF";                   vtypes[39] = "void **"
     types[40] = "UNWINDWORD";                   vtypes[40] = "void *"
     types[41] = "WORD";                         vtypes[41] = ""
     types[42] = "SSIZE";                        vtypes[42] = "long int"
     types[43] = "PID";                          vtypes[43] = "int"
+    types[29] = "PTR_CONST_STRING";                     vtypes[29] = "char *const"
+    types[30] = "PTRMODE_PTR";                          vtypes[30] = ""
+    types[31] = "PTRPTR";                                       vtypes[31] = "void **"
+    types[32] = "PTR";                                          vtypes[32] = "void *"
+    types[33] = "VOID";                                         vtypes[33] = "void"
+    types[34] = "STRING";                                       vtypes[34] = "char *"
+    types[35] = "FILEPTR";                                      vtypes[35] = "struct _IO_FILE *"
+    types[36] = "SIZE";                                         vtypes[36] = "unsigned long"
+    types[37] = "VAR";                                          vtypes[37] = "..."
+    types[38] = "VALIST_ARG";                           vtypes[38] = "void **"
+    types[39] = "VALIST_REF";                           vtypes[39] = "void **"
+    types[40] = "UNWINDWORD";                           vtypes[40] = "void *"
+    types[41] = "WORD";                                         vtypes[41] = ""
+    types[42] = "SSIZE";                                        vtypes[42] = "long int"
+    types[43] = "PID";                                          vtypes[43] = "int"
     N = 44
 } # BEGIN
 …
     # generate C types for macros names
     for ( i = 0; i < N; i += 1 ) {
         printf( "#define BT_%s %s\n", types[i], vtypes[i] )
+                printf( "#define BT_%s %s\n", types[i], vtypes[i] )
     } # for
     printf( "\n" )
     for ( prototype in prototypes ) {
         if ( index( "BT_LAST", prototype ) == 1 ) {
             continue
         } # if
+                if ( index( "BT_LAST", prototype ) == 1 ) {
+                        continue
+                } # if
         printf( "#define %s(NAME) FUNC_SIMPLE(", prototype )
+                printf( "#define %s(NAME) FUNC_SIMPLE(", prototype )
         if ( sub( "BT_FN_", "", prototype ) == 0 ) {
             printf( "\n********** BAD MACRO NAME \"%s\" **********\n", prototype )
             exit 0
         } # if
+                if ( sub( "BT_FN_", "", prototype ) == 0 ) {
+                        printf( "\n********** BAD MACRO NAME \"%s\" **********\n", prototype )
+                        exit 0
+                } # if
         # generate function return type as macro
         for ( t = 0; t < N; t += 1 ) {                  # find longest match
             type = types[t];
             if ( index( prototype, type ) == 1 ) {      # found match
                 printf( "BT_%s, NAME", type )
                 sub( type, "", prototype )
                 break;
             } # if
         } # for
+                # generate function return type as macro
+                for ( t = 0; t < N; t += 1 ) {                                  # find longest match
+                        type = types[t];
+                        if ( index( prototype, type ) == 1 ) {          # found match
+                                printf( "BT_%s, NAME", type )
+                                sub( type, "", prototype )
+                                break;
+                        } # if
+                } # for
+        # generate function parameter types as macro
+        if ( index( prototype, "VAR" ) != 2 ) {         # C-style empty parameters ?
+            for ( p = 0; length( prototype ) > 0; p += 1 ) { # until all parameters types are removed
+                sub( "_", "", prototype)                # remove "_"
+                printf( ", ", type )
+                temp = prototype
+                for ( t = 0; t < N; t += 1 ) {          # find longest match
+                    type = types[t];
+                    if ( index( prototype, type ) == 1 ) { # found match
+                        printf( "BT_%s", type )
+                        sub( type, "", prototype )
+                        break;
+                    } # if
+                } # for
+                if ( temp == prototype ) {              # no match found for parameter in macro table
+                    printf( "\n********** MISSING TYPE \"%s\" **********\n", prototype )
+                    exit 0
+                # generate function parameter types as macro
+                if ( index( prototype, "VAR" ) != 2 ) {                 # C-style empty parameters ?
+                        for ( p = 0; length( prototype ) > 0; p += 1 ) { # until all parameters types are removed
+                                sub( "_", "", prototype)                                # remove "_"
+                                printf( ", ", type )
+                                temp = prototype
+                                for ( t = 0; t < N; t += 1 ) {                  # find longest match
+                                        type = types[t];
+                                        if ( index( prototype, type ) == 1 ) { # found match
+                                                printf( "BT_%s", type )
+                                                sub( type, "", prototype )
+                                                break;
+                                        } # if
+                                } # for
+                                if ( temp == prototype ) {                              # no match found for parameter in macro table
+                                        printf( "\n********** MISSING TYPE \"%s\" **********\n", prototype )
+                                        exit 0
+                                } # if
+                        } # for
                 } # if
+            } # for
+        } # if
+        printf( ")\n" )
+                printf( ")\n" )
     } # for
 …
     printf( "typedef int wchar_t;\n" );
 } # END
+# Local Variables: #
+# tab-width: 4 #
+# mode: awk #
+# compile-command: "make install" #
+# End: #

translator/ArgTweak/FunctionFixer.cc

-                      rb8508a2
+                      rb87a5ed
+//
+// 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.
+//
+// FunctionFixer.cc --
+//
+// Author           : Peter A. Buhr
+// Created On       : Sat May 16 08:12:38 2015
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Sat May 16 08:17:07 2015
+// Update Count     : 5
+//
 #include <list>
 #include <vector>
 …
 namespace ArgTweak {
+        FunctionFixer::FunctionFixer( SymTab::Indexer *ind ) : index( ind ) {
+                if ( index == 0 ) index = new SymTab::Indexer();
+        }
+        FunctionFixer::~FunctionFixer() {
+                delete index;
+        }
+  FunctionFixer::FunctionFixer( SymTab::Indexer *ind ) : index( ind )
+  {
+    if ( index == 0 ) index = new SymTab::Indexer();
+  }
+        DeclarationWithType *FunctionFixer::mutate( FunctionDecl *functionDecl ) {
+                index->visit( functionDecl );
+                /* check for duplicate named parameters here?  It might not be an error if they're never used, on the other hand, it
+                   might be to costly to check for duplicates every time we try a match */
+                return Parent::mutate( functionDecl );
+        }
+  FunctionFixer::~FunctionFixer()
+  {
+    delete index;
+  }
+        Expression *FunctionFixer::mutate( UntypedExpr *untypedExpr ) throw ( SemanticError ) {
+                assert( untypedExpr != 0 );
+                NameExpr *function;
+  DeclarationWithType *FunctionFixer::mutate( FunctionDecl *functionDecl )
+  {
+    index->visit( functionDecl );
+    /* check for duplicate named parameters here?  It might not be an
+    error if they're never used, on the other hand, it might be to
+    costly to check for duplicates every time we try a match */
+    return Parent::mutate( functionDecl );
+  }
+                if ( ( function = dynamic_cast< NameExpr *>(untypedExpr->get_function()) ) != 0 ) {
+                        std::list < DeclarationWithType * > options;
+                        index->lookupId ( function->get_name(), options );
+                        for ( std::list < DeclarationWithType * >::iterator i = options.begin(); i != options.end(); i++ ) {
+                                FunctionType *f;
+                                if ( ( f = dynamic_cast< FunctionType * > ( (*i)->get_type() ) ) != 0 ) {
+                                        std::list < DeclarationWithType * > &pars = f->get_parameters();
+  Expression *FunctionFixer::mutate( UntypedExpr *untypedExpr )
+    throw ( SemanticError )
+  {
+    assert( untypedExpr != 0 );
+    NameExpr *function;
+                                        bool candidateExists ;
+                                        for ( std::list < DeclarationWithType * >::iterator p = pars.begin(); p != pars.end(); p++ )
+                                                if ( ( candidateExists = align( f->get_parameters(), untypedExpr->get_args(), Matcher() ) ) ) break;
+    if ( ( function = dynamic_cast< NameExpr *>(untypedExpr->get_function()) ) != 0 )
+      {
+        std::list < DeclarationWithType * > options;
+        index->lookupId ( function->get_name(), options );
+        for ( std::list < DeclarationWithType * >::iterator i = options.begin(); i != options.end(); i++ )
+          {
+            FunctionType *f;
+            if ( ( f = dynamic_cast< FunctionType * > ( (*i)->get_type() ) ) != 0 )
+              {
+                std::list < DeclarationWithType * > &pars = f->get_parameters();
+                                        if ( !candidateExists ) throw SemanticError("Error in function call");
+                                } // if
+                        } // for
+                } // if
+                return untypedExpr;
+        }
+                bool candidateExists ;
+                for( std::list < DeclarationWithType * >::iterator p = pars.begin(); p != pars.end(); p++ )
+                  if ( ( candidateExists = align( f->get_parameters(), untypedExpr->get_args(), Matcher() ) ) ) break;
+        template < class L1, class L2, class Helper >
+        bool align( L1 &pattern, L2 &possible_permutation, Helper help ) {
+                std::map < typename Helper::key, int > positions;
+                int p = 0;
+                if ( !candidateExists ) throw SemanticError("Error in function call");
+              }
+          }
+      }
+    return untypedExpr;
+  }
+                for ( typename L1::iterator i = pattern.begin(); i != pattern.end(); i++, p++ )
+                        if ( help.extract_key( *i ) != Helper::null_key )
+                                positions[ help.extract_key( *i ) ] = p;
+  template < class L1, class L2, class Helper >
+  bool align( L1 &pattern, L2 &possible_permutation, Helper help )
+  {
+    std::map < typename Helper::key, int > positions;
+    int p = 0;
+                L2 copy_pp( possible_permutation );
+    for ( typename L1::iterator i = pattern.begin(); i != pattern.end(); i++, p++ )
+      if ( help.extract_key( *i ) != Helper::null_key )
+        positions[ help.extract_key( *i ) ] = p;
+                std::vector< typename L2::value_type > temp(copy_pp.size(), Helper::null_value );
+                for ( typename L2::iterator i = copy_pp.begin(); i != copy_pp.end(); i++ )
+                        if ( positions.find( help.extract_key( *i ) ) != positions.end() ) {
+                                temp [ positions [ help.extract_key( *i ) ] ] = *i;
+                                *i = Helper::null_value;
+                        } // if
+    L2 copy_pp( possible_permutation );
+                // rest of the arguments
+                int a = 0;
+                bool goAhead = true;                                                    // go ahead and change the list
+                for ( typename L2::iterator i = copy_pp.begin(); i != copy_pp.end(); i++, a++ ) {
+                        if (  *i != Helper::null_value )
+                                if ( temp[a] == Helper::null_value )
+                                        temp[a] = *i;
+                                else
+                                        { goAhead = false; /* there's something there already */; break; }
+                        else
+                                if ( temp[a] == Helper::null_value )
+                                        { goAhead = false; /* can't leave empty spaces */ break; }
+                                else
+                                        ;                                                                       // all good, this was filled during the first pass
+                        assert ( temp[a] != Helper::null_value );
+                } // for
+    std::vector< typename L2::value_type > temp(copy_pp.size(), Helper::null_value );
+    for ( typename L2::iterator i = copy_pp.begin(); i != copy_pp.end(); i++ )
+      if ( positions.find( help.extract_key( *i ) ) != positions.end() ) {
+        temp [ positions [ help.extract_key( *i ) ] ] = *i;
+        *i = Helper::null_value;
+      }
+                // Change the original list
+                if ( goAhead ) std::copy( temp.begin(), temp.end(), possible_permutation.begin() );
+    // rest of the arguments
+    int a = 0;
+    bool goAhead = true;  // go ahead and change the list
+    for ( typename L2::iterator i = copy_pp.begin(); i != copy_pp.end(); i++, a++ ) {
+      if (  *i != Helper::null_value )
+        if ( temp[a] == Helper::null_value )
+          temp[a] = *i;
+        else
+          { goAhead = false; /* there's something there already */; break; }
+      else
+        if ( temp[a] == Helper::null_value )
+          { goAhead = false; /* can't leave empty spaces */ break; }
+        else
+          ; // all good, this was filled during the first pass
+      assert ( temp[a] != Helper::null_value );
+    }
+                return goAhead;
+        }
+    // Change the original list
     if ( goAhead ) std::copy( temp.begin(), temp.end(), possible_permutation.begin() );
+        std::string FunctionFixer::Matcher::null_key("");
+        Expression *FunctionFixer::Matcher::null_value = 0;
+    return goAhead;
+  }
+        std::string FunctionFixer::Matcher::extract_key ( DeclarationWithType *decl ) {
+                return decl->get_name();
+        }
+  std::string FunctionFixer::Matcher::null_key("");
+  Expression *FunctionFixer::Matcher::null_value = 0;
+        std::string FunctionFixer::Matcher::extract_key ( Expression *expression ) {
+                if ( expression->get_argName() == 0 )
+                        return std::string("");
+                else
+                        return *(expression->get_argName());
+        }
+} // namespace ArgTweak
+  std::string FunctionFixer::Matcher::extract_key ( DeclarationWithType *decl ) {
+    return decl->get_name();
+  }
+  std::string FunctionFixer::Matcher::extract_key ( Expression *expression ) {
+    if ( expression->get_argName() == 0 )
+      return std::string("");
+    else
+      return *(expression->get_argName());
+  }
+} // namespace ArgTweak
+// Local Variables: //
+// tab-width: 4 //
+// mode: c++ //
+// compile-command: "make install" //
+// End: //

translator/MakeLibCfa.cc

-                      rb8508a2
+                      rb87a5ed
+/*
+ * This file is part of the Cforall project
+ *
+ * $Id: MakeLibCfa.cc,v 1.6 2005/08/29 20:14:14 rcbilson Exp $
+ *
+ */
+//
+// 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.
+//
+// MakeLibCfa.cc --
+//
+// Author           : Richard C. Bilson
+// Created On       : Sat May 16 10:33:33 2015
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Sat May 16 10:40:44 2015
+// Update Count     : 13
+//
 #include "MakeLibCfa.h"
+#include "SynTree/Visitor.h"
 #include "SynTree/Declaration.h"
 #include "SynTree/Type.h"
 …
 #include "SynTree/Statement.h"
 #include "SynTree/Initializer.h"
-#include "SynTree/Visitor.h"
 #include "CodeGen/OperatorTable.h"
 #include "UniqueName.h"
+namespace LibCfa {
+        class MakeLibCfa : public Visitor {
+          public:
+                void visit( FunctionDecl* funcDecl );
+                void visit( ObjectDecl* objDecl );
+                std::list< Declaration* > &get_newDecls() { return newDecls; }
+          private:
+                std::list< Declaration* > newDecls;
+        };
+namespace LibCfa {
+        void makeLibCfa( std::list< Declaration* > &prelude ) {
+                MakeLibCfa maker;
+                acceptAll( prelude, maker );
+                prelude.splice( prelude.end(), maker.get_newDecls() );
+        }
+class MakeLibCfa : public Visitor
+{
+public:
+  void visit( FunctionDecl* funcDecl );
+  void visit( ObjectDecl* objDecl );
+        void MakeLibCfa::visit( FunctionDecl* origFuncDecl ) {
+                if ( origFuncDecl->get_linkage() != LinkageSpec::Intrinsic ) return;
+  std::list< Declaration* > &get_newDecls() { return newDecls; }
+                FunctionDecl *funcDecl = origFuncDecl->clone();
+                CodeGen::OperatorInfo opInfo;
+                bool lookResult = CodeGen::operatorLookup( funcDecl->get_name(), opInfo );
+                assert( lookResult );
+                assert( !funcDecl->get_statements() );
+                UntypedExpr *newExpr = new UntypedExpr( new NameExpr( funcDecl->get_name() ) );
+                UniqueName paramNamer( "_p" );
+                std::list< DeclarationWithType* >::iterator param = funcDecl->get_functionType()->get_parameters().begin();
+                assert( param != funcDecl->get_functionType()->get_parameters().end() );
+                if ( (*param)->get_name() == "" ) {
+                        (*param)->set_name( paramNamer.newName() );
+                        (*param)->set_linkage( LinkageSpec::C );
+                } // if
+                switch( opInfo.type ) {
+                  case CodeGen::OT_INDEX:
+                  case CodeGen::OT_CALL:
+                  case CodeGen::OT_PREFIX:
+                  case CodeGen::OT_POSTFIX:
+                  case CodeGen::OT_INFIX:
+                        newExpr->get_args().push_back( new VariableExpr( *param ) );
+                        break;
+                  case CodeGen::OT_PREFIXASSIGN:
+                  case CodeGen::OT_POSTFIXASSIGN:
+                  case CodeGen::OT_INFIXASSIGN:
+                        {
+                                newExpr->get_args().push_back( new VariableExpr( *param ) );
+                                // UntypedExpr *deref = new UntypedExpr( new NameExpr( "*?" ) );
+                                // deref->get_args().push_back( new VariableExpr( *param ) );
+                                // newExpr->get_args().push_back( deref );
+                                break;
+                        }
+                  case CodeGen::OT_CONSTANT:
+                        assert( false );
+                } // switch
+                for ( param++; param != funcDecl->get_functionType()->get_parameters().end(); ++param ) {
+                        if ( (*param)->get_name() == "" ) {
+                                (*param)->set_name( paramNamer.newName() );
+                                (*param)->set_linkage( LinkageSpec::C );
+                        }
+                        newExpr->get_args().push_back( new VariableExpr( *param ) );
+                } // for
+                funcDecl->set_statements( new CompoundStmt( std::list< Label >() ) );
+                funcDecl->get_statements()->get_kids().push_back( new ReturnStmt( std::list< Label >(), newExpr ) );
+                newDecls.push_back( funcDecl );
+        }
+        void MakeLibCfa::visit( ObjectDecl* origObjDecl ) {
+                if ( origObjDecl->get_linkage() != LinkageSpec::Intrinsic ) return;
+private:
+  std::list< Declaration* > newDecls;
+};
+                ObjectDecl *objDecl = origObjDecl->clone();
+                assert( !objDecl->get_init() );
+                std::list< Expression* > noDesignators;
+                objDecl->set_init( new SingleInit( new NameExpr( objDecl->get_name() ), noDesignators ) );
+                newDecls.push_back( objDecl );
+        }
+} // namespace LibCfa
+void
+makeLibCfa( std::list< Declaration* > &prelude )
+{
+  MakeLibCfa maker;
+  acceptAll( prelude, maker );
+  prelude.splice( prelude.end(), maker.get_newDecls() );
+}
+void
+MakeLibCfa::visit( FunctionDecl* origFuncDecl )
+{
+  if( origFuncDecl->get_linkage() != LinkageSpec::Intrinsic ) return;
+  FunctionDecl *funcDecl = origFuncDecl->clone();
+  CodeGen::OperatorInfo opInfo;
+  bool lookResult = CodeGen::operatorLookup( funcDecl->get_name(), opInfo );
+  assert( lookResult );
+  assert( !funcDecl->get_statements() );
+  UntypedExpr *newExpr = new UntypedExpr( new NameExpr( funcDecl->get_name() ) );
+  UniqueName paramNamer( "_p" );
+  std::list< DeclarationWithType* >::iterator param = funcDecl->get_functionType()->get_parameters().begin();
+  assert( param != funcDecl->get_functionType()->get_parameters().end() );
+  if( (*param)->get_name() == "" ) {
+    (*param)->set_name( paramNamer.newName() );
+    (*param)->set_linkage( LinkageSpec::C );
+  }
+  switch( opInfo.type ) {
+  case CodeGen::OT_INDEX:
+  case CodeGen::OT_CALL:
+  case CodeGen::OT_PREFIX:
+  case CodeGen::OT_POSTFIX:
+  case CodeGen::OT_INFIX:
+    newExpr->get_args().push_back( new VariableExpr( *param ) );
+    break;
+  case CodeGen::OT_PREFIXASSIGN:
+  case CodeGen::OT_POSTFIXASSIGN:
+  case CodeGen::OT_INFIXASSIGN:
+  {
+    newExpr->get_args().push_back( new VariableExpr( *param ) );
+///     UntypedExpr *deref = new UntypedExpr( new NameExpr( "*?" ) );
+///     deref->get_args().push_back( new VariableExpr( *param ) );
+///     newExpr->get_args().push_back( deref );
+    break;
+  }
+  case CodeGen::OT_CONSTANT:
+    assert( false );
+  }
+  for( param++; param != funcDecl->get_functionType()->get_parameters().end(); ++param ) {
+    if( (*param)->get_name() == "" ) {
+      (*param)->set_name( paramNamer.newName() );
+      (*param)->set_linkage( LinkageSpec::C );
+    }
+    newExpr->get_args().push_back( new VariableExpr( *param ) );
+  }
+  funcDecl->set_statements( new CompoundStmt( std::list< Label >() ) );
+  funcDecl->get_statements()->get_kids().push_back( new ReturnStmt( std::list< Label >(), newExpr ) );
+  newDecls.push_back( funcDecl );
+}
+void
+MakeLibCfa::visit( ObjectDecl* origObjDecl )
+{
+  if( origObjDecl->get_linkage() != LinkageSpec::Intrinsic ) return;
+  ObjectDecl *objDecl = origObjDecl->clone();
+  assert( !objDecl->get_init() );
+  std::list< Expression* > noDesignators;
+  objDecl->set_init( new SingleInit( new NameExpr( objDecl->get_name() ), noDesignators ) );
+  newDecls.push_back( objDecl );
+}
+} // namespace LibCfa
+// Local Variables: //
+// tab-width: 4 //
+// mode: c++ //
+// compile-command: "make install" //
+// End: //

translator/MakeLibCfa.h

-                      rb8508a2
+                      rb87a5ed
+/*
+ * This file is part of the Cforall project
+ *
+ * $Id: MakeLibCfa.h,v 1.2 2005/08/29 20:14:14 rcbilson Exp $
+ *
+ */
+//
+// 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.
+//
+// MakeLibCfa.h --
+//
+// Author           : Richard C. Bilson
+// Created On       : Sat May 16 10:42:14 2015
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Sat May 16 10:43:29 2015
+// Update Count     : 1
+//
 #ifndef LIBCFA_MAKELIBCFA_H
 …
 namespace LibCfa {
+void makeLibCfa( std::list< Declaration* > &prelude );
+        void makeLibCfa( std::list< Declaration* > &prelude );
 } // namespace LibCfa
+#endif /* #ifndef LIBCFA_MAKELIBCFA_H */
+#endif // LIBCFA_MAKELIBCFA_H
+// Local Variables: //
+// tab-width: 4 //
+// mode: c++ //
+// compile-command: "make install" //
+// End: //

translator/Makefile.in

-                      rb8508a2
+                      rb87a5ed
+# This makefile is adapted from Peter Miller's article
+# "Recursive Make Considered Harmful"
+#
+# http://www.pcug.org.au/~millerp/rmch/recu-make-cons-harm.html
+######################### -*- Mode: Makefile-Gmake -*- ########################
+##
+## 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.
+##
+## Makefile.in --
+##
+## Author           : Peter A. Buhr
+## Created On       : Sat May 16 08:37:37 2015
+## Last Modified By : Peter A. Buhr
+## Last Modified On : Sat May 16 08:38:52 2015
+## Update Count     : 2
+###############################################################################
+MODULES := Common Parser SynTree SymTab ResolvExpr CodeGen ControlStruct GenPoly Tuples InitTweak Designators #Try ArgTweak Explain
+# This makefile is adapted from Peter Miller's article "Recursive Make Considered Harmful"
+MODULES := Common Parser SynTree SymTab ResolvExpr CodeGen ControlStruct GenPoly Tuples InitTweak Designators # Try ArgTweak Explain
 TARGET := cfa-cpp
 all: $(TARGET)
+all: ${TARGET}
 # look for include files in each of the modules
 …
 # this is the back-end compiler, used to compile libcfa & builtins to link with user code
 BACKEND_CC := @BACKEND_CC@
-# uncomment the definition of this variable to enable purify
-#  (do a "purerun" first)
-#PURIFY := purify --cache-dir=$(HOME)/tmp
 # extra libraries if required
 …
 # include the description for each module
 include $(patsubst %,%/module.mk,$(MODULES))
+include ${patsubst %,%/module.mk,${MODULES}}
 # determine the object files
 OBJ := $(patsubst %.cc,%.o,$(filter %.cc,$(SRC))) \
        $(patsubst %.y,%.tab.o,$(filter %.y,$(SRC))) \
        $(patsubst %.l,%.yy.o,$(filter %.l,$(SRC)))
+OBJ := ${patsubst %.cc,%.o,${filter %.cc,${SRC}}} \
+       ${patsubst %.y,%.tab.o,${filter %.y,${SRC}}} \
+       ${patsubst %.l,%.yy.o,${filter %.l,${SRC}}}
 # include the C include dependencies
 DEPS := $(OBJ:.o=.d)
 -include $(DEPS)
+DEPS := ${OBJ:.o=.d}
+-include ${DEPS}
 # link the program
 $(TARGET): $(OBJ)
         $(PURIFY) $(CXX) -o $@ $(OBJ) $(LIBS)
+${TARGET}: ${OBJ}
+        ${PURIFY} ${CXX} -o $@ ${OBJ} ${LIBS}
 #installing
 install: $(TARGET)
         $(INSTALL) -d @CFA_LIBDIR@
         $(INSTALL) $(TARGET) @CFA_LIBDIR@
+install: ${TARGET}
+        ${INSTALL} -d @CFA_LIBDIR@
+        ${INSTALL} ${TARGET} @CFA_LIBDIR@
 # clean-up rule
 clean:
         rm -f $(OBJ) $(DEPS) $(TARGET) tags $(EXTRA_OUTPUT)
+        rm -f ${OBJ} ${DEPS} ${TARGET} tags ${EXTRA_OUTPUT}
         find . -name "Expected*" -prune -o \( -name "*.tst" -o -name "report" \) -print | xargs rm -f
         find . -name "core*" -print | xargs rm -f

translator/Parser/DeclarationNode.cc

-                      rb8508a2
+                      rb87a5ed
+//
+// 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.
+//
+// DeclarationNode.cc --
+//
+// Author           : Rodolfo G. Esteves
+// Created On       : Sat May 16 12:34:05 2015
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Sat May 16 12:38:20 2015
+// Update Count     : 4
+//
 #include <string>
 #include <list>
 …
 DeclarationNode *DeclarationNode::clone() const {
     DeclarationNode *newnode = new DeclarationNode;
     newnode->type = maybeClone( type );
     newnode->name = name;
     newnode->storageClasses = storageClasses;
     newnode->bitfieldWidth = maybeClone( bitfieldWidth );
     newnode->hasEllipsis = hasEllipsis;
     newnode->initializer = initializer;
     newnode->next = maybeClone( next );
     newnode->linkage = linkage;
     return newnode;
+        DeclarationNode *newnode = new DeclarationNode;
+        newnode->type = maybeClone( type );
+        newnode->name = name;
+        newnode->storageClasses = storageClasses;
+        newnode->bitfieldWidth = maybeClone( bitfieldWidth );
+        newnode->hasEllipsis = hasEllipsis;
+        newnode->initializer = initializer;
+        newnode->next = maybeClone( next );
+        newnode->linkage = linkage;
+        return newnode;
+}
 …
 DeclarationNode::~DeclarationNode() {
     delete type;
     delete bitfieldWidth;
     delete initializer;
+        delete type;
+        delete bitfieldWidth;
+        delete initializer;
+}
 bool DeclarationNode::get_hasEllipsis() const {
     return hasEllipsis;
+        return hasEllipsis;
+}
 const char *storageClassName[] = {
     // order must correspond with DeclarationNode::StorageClass
     "extern",
     "static",
     "auto",
     "register",
     "inline",
     "fortran",
+        // order must correspond with DeclarationNode::StorageClass
+        "extern",
+        "static",
+        "auto",
+        "register",
+        "inline",
+        "fortran",
 };
 void DeclarationNode::print( std::ostream &os, int indent ) const {
     os << string(indent, ' ' );
     if ( name == "" ) {
         os << "unnamed: ";
     } else {
         os << name << ": ";
+    }
     if ( linkage != LinkageSpec::Cforall ) {
         os << LinkageSpec::toString( linkage ) << " ";
+    }
     printEnums( storageClasses.begin(), storageClasses.end(), storageClassName, os );
     if ( type ) {
         type->print( os, indent );
     } else {
         os << "untyped entity ";
+    }
     if ( bitfieldWidth ) {
         os << endl << string(indent+2,  ' ') << "with bitfield width ";
         bitfieldWidth->printOneLine( os );
+    }
     if ( initializer != 0 ) {
         os << endl << string(indent+2,  ' ') << "with initializer ";
         initializer->printOneLine( os );
+    }
     os << endl;
+        os << string(indent, ' ' );
+        if ( name == "" ) {
+                os << "unnamed: ";
+        } else {
+                os << name << ": ";
+        }
+        if ( linkage != LinkageSpec::Cforall ) {
+                os << LinkageSpec::toString( linkage ) << " ";
+        }
+        printEnums( storageClasses.begin(), storageClasses.end(), storageClassName, os );
+        if ( type ) {
+                type->print( os, indent );
+        } else {
+                os << "untyped entity ";
+        }
+        if ( bitfieldWidth ) {
+                os << endl << string(indent+2,  ' ') << "with bitfield width ";
+                bitfieldWidth->printOneLine( os );
+        }
+        if ( initializer != 0 ) {
+                os << endl << string(indent+2,  ' ') << "with initializer ";
+                initializer->printOneLine( os );
+        }
+        os << endl;
+}
 void DeclarationNode::printList( std::ostream &os, int indent ) const {
     ParseNode::printList( os, indent );
     if ( hasEllipsis ) {
         os << string( indent, ' ' )  << "and a variable number of other arguments" << endl;
+    }
+        ParseNode::printList( os, indent );
+        if ( hasEllipsis ) {
+                os << string( indent, ' ' )  << "and a variable number of other arguments" << endl;
+        }
+}
 DeclarationNode *DeclarationNode::newFunction( std::string *name, DeclarationNode *ret, DeclarationNode *param, StatementNode *body, bool newStyle ) {
     DeclarationNode *newnode = new DeclarationNode;
     newnode->name = assign_strptr( name );
     newnode->type = new TypeData( TypeData::Function );
     newnode->type->function->params = param;
     newnode->type->function->newStyle = newStyle;
     newnode->type->function->body = body;
     if ( body ) {
         newnode->type->function->hasBody = true;
+    }
     if ( ret ) {
         newnode->type->base = ret->type;
         ret->type = 0;
         delete ret;
+    }
     return newnode;
+        DeclarationNode *newnode = new DeclarationNode;
+        newnode->name = assign_strptr( name );
+        newnode->type = new TypeData( TypeData::Function );
+        newnode->type->function->params = param;
+        newnode->type->function->newStyle = newStyle;
+        newnode->type->function->body = body;
+        if ( body ) {
+                newnode->type->function->hasBody = true;
+        }
+        if ( ret ) {
+                newnode->type->base = ret->type;
+                ret->type = 0;
+                delete ret;
+        }
+        return newnode;
+}
 DeclarationNode *DeclarationNode::newQualifier( Qualifier q ) {
     DeclarationNode *newnode = new DeclarationNode;
     newnode->type = new TypeData();
     newnode->type->qualifiers.push_back( q );
     return newnode;
+        DeclarationNode *newnode = new DeclarationNode;
+        newnode->type = new TypeData();
+        newnode->type->qualifiers.push_back( q );
+        return newnode;
+}
 DeclarationNode *DeclarationNode::newStorageClass( StorageClass sc ) {
     DeclarationNode *newnode = new DeclarationNode;
     newnode->storageClasses.push_back( sc );
     return newnode;
+        DeclarationNode *newnode = new DeclarationNode;
+        newnode->storageClasses.push_back( sc );
+        return newnode;
+}
 DeclarationNode *DeclarationNode::newBasicType( BasicType bt ) {
     DeclarationNode *newnode = new DeclarationNode;
     newnode->type = new TypeData( TypeData::Basic );
     newnode->type->basic->typeSpec.push_back( bt );
     return newnode;
+        DeclarationNode *newnode = new DeclarationNode;
+        newnode->type = new TypeData( TypeData::Basic );
+        newnode->type->basic->typeSpec.push_back( bt );
+        return newnode;
+}
 DeclarationNode *DeclarationNode::newModifier( Modifier mod ) {
     DeclarationNode *newnode = new DeclarationNode;
     newnode->type = new TypeData( TypeData::Basic );
     newnode->type->basic->modifiers.push_back( mod );
     return newnode;
+        DeclarationNode *newnode = new DeclarationNode;
+        newnode->type = new TypeData( TypeData::Basic );
+        newnode->type->basic->modifiers.push_back( mod );
+        return newnode;
+}
 DeclarationNode *DeclarationNode::newForall( DeclarationNode* forall ) {
     DeclarationNode *newnode = new DeclarationNode;
     newnode->type = new TypeData( TypeData::Unknown );
     newnode->type->forall = forall;
     return newnode;
+        DeclarationNode *newnode = new DeclarationNode;
+        newnode->type = new TypeData( TypeData::Unknown );
+        newnode->type->forall = forall;
+        return newnode;
+}
 DeclarationNode *DeclarationNode::newFromTypedef( std::string* name ) {
     DeclarationNode *newnode = new DeclarationNode;
     newnode->type = new TypeData( TypeData::SymbolicInst );
     newnode->type->symbolic->name = assign_strptr( name );
     newnode->type->symbolic->isTypedef = true;
     newnode->type->symbolic->params = 0;
     return newnode;
+        DeclarationNode *newnode = new DeclarationNode;
+        newnode->type = new TypeData( TypeData::SymbolicInst );
+        newnode->type->symbolic->name = assign_strptr( name );
+        newnode->type->symbolic->isTypedef = true;
+        newnode->type->symbolic->params = 0;
+        return newnode;
+}
 DeclarationNode *DeclarationNode::newAggregate( TyCon kind, std::string* name, DeclarationNode *formals, ExpressionNode *actuals, DeclarationNode *fields ) {
     DeclarationNode *newnode = new DeclarationNode;
     newnode->type = new TypeData( TypeData::Aggregate );
     newnode->type->aggregate->kind = kind;
     newnode->type->aggregate->name = assign_strptr( name );
     if ( newnode->type->aggregate->name == "" ) {
         newnode->type->aggregate->name = DeclarationNode::anonymous.newName();
+    }
     newnode->type->aggregate->params = formals;
     newnode->type->aggregate->actuals = actuals;
     newnode->type->aggregate->members = fields;
     return newnode;
+        DeclarationNode *newnode = new DeclarationNode;
+        newnode->type = new TypeData( TypeData::Aggregate );
+        newnode->type->aggregate->kind = kind;
+        newnode->type->aggregate->name = assign_strptr( name );
+        if ( newnode->type->aggregate->name == "" ) {
+                newnode->type->aggregate->name = DeclarationNode::anonymous.newName();
+        }
+        newnode->type->aggregate->params = formals;
+        newnode->type->aggregate->actuals = actuals;
+        newnode->type->aggregate->members = fields;
+        return newnode;
+}
 DeclarationNode *DeclarationNode::newEnum( std::string *name, DeclarationNode *constants ) {
     DeclarationNode *newnode = new DeclarationNode;
     newnode->name = assign_strptr( name );
     newnode->type = new TypeData( TypeData::Enum );
     newnode->type->enumeration->name = newnode->name;
     if ( newnode->type->enumeration->name == "" ) {
         newnode->type->enumeration->name = DeclarationNode::anonymous.newName();
+    }
     newnode->type->enumeration->constants = constants;
     return newnode;
+        DeclarationNode *newnode = new DeclarationNode;
+        newnode->name = assign_strptr( name );
+        newnode->type = new TypeData( TypeData::Enum );
+        newnode->type->enumeration->name = newnode->name;
+        if ( newnode->type->enumeration->name == "" ) {
+                newnode->type->enumeration->name = DeclarationNode::anonymous.newName();
+        }
+        newnode->type->enumeration->constants = constants;
+        return newnode;
+}
 DeclarationNode *DeclarationNode::newEnumConstant( std::string* name, ExpressionNode *constant ) {
     DeclarationNode *newnode = new DeclarationNode;
     newnode->name = assign_strptr( name );
     // do something with the constant
     return newnode;
+        DeclarationNode *newnode = new DeclarationNode;
+        newnode->name = assign_strptr( name );
+        // do something with the constant
+        return newnode;
+}
 DeclarationNode *DeclarationNode::newName( std::string* name ) {
     DeclarationNode *newnode = new DeclarationNode;
     newnode->name = assign_strptr( name );
     return newnode;
+        DeclarationNode *newnode = new DeclarationNode;
+        newnode->name = assign_strptr( name );
+        return newnode;
+}
 DeclarationNode *DeclarationNode::newFromTypeGen( std::string* name, ExpressionNode *params ) {
     DeclarationNode *newnode = new DeclarationNode;
     newnode->type = new TypeData( TypeData::SymbolicInst );
     newnode->type->symbolic->name = assign_strptr( name );
     newnode->type->symbolic->isTypedef = false;
     newnode->type->symbolic->actuals = params;
     return newnode;
+        DeclarationNode *newnode = new DeclarationNode;
+        newnode->type = new TypeData( TypeData::SymbolicInst );
+        newnode->type->symbolic->name = assign_strptr( name );
+        newnode->type->symbolic->isTypedef = false;
+        newnode->type->symbolic->actuals = params;
+        return newnode;
+}
 DeclarationNode *DeclarationNode::newTypeParam( TypeClass tc, std::string* name ) {
     DeclarationNode *newnode = new DeclarationNode;
     newnode->name = assign_strptr( name );
     newnode->type = new TypeData( TypeData::Variable );
     newnode->type->variable->tyClass = tc;
     newnode->type->variable->name = newnode->name;
     return newnode;
+        DeclarationNode *newnode = new DeclarationNode;
+        newnode->name = assign_strptr( name );
+        newnode->type = new TypeData( TypeData::Variable );
+        newnode->type->variable->tyClass = tc;
+        newnode->type->variable->name = newnode->name;
+        return newnode;
+}
 DeclarationNode *DeclarationNode::newContext( std::string *name, DeclarationNode *params, DeclarationNode *asserts ) {
     DeclarationNode *newnode = new DeclarationNode;
     newnode->type = new TypeData( TypeData::Aggregate );
     newnode->type->aggregate->kind = Context;
     newnode->type->aggregate->params = params;
     newnode->type->aggregate->members = asserts;
     newnode->type->aggregate->name = assign_strptr( name );
     return newnode;
+        DeclarationNode *newnode = new DeclarationNode;
+        newnode->type = new TypeData( TypeData::Aggregate );
+        newnode->type->aggregate->kind = Context;
+        newnode->type->aggregate->params = params;
+        newnode->type->aggregate->members = asserts;
+        newnode->type->aggregate->name = assign_strptr( name );
+        return newnode;
+}
 DeclarationNode *DeclarationNode::newContextUse( std::string *name, ExpressionNode *params ) {
     DeclarationNode *newnode = new DeclarationNode;
     newnode->type = new TypeData( TypeData::AggregateInst );
     newnode->type->aggInst->aggregate = new TypeData( TypeData::Aggregate );
     newnode->type->aggInst->aggregate->aggregate->kind = Context;
     newnode->type->aggInst->aggregate->aggregate->name = assign_strptr( name );
     newnode->type->aggInst->params = params;
     return newnode;
+        DeclarationNode *newnode = new DeclarationNode;
+        newnode->type = new TypeData( TypeData::AggregateInst );
+        newnode->type->aggInst->aggregate = new TypeData( TypeData::Aggregate );
+        newnode->type->aggInst->aggregate->aggregate->kind = Context;
+        newnode->type->aggInst->aggregate->aggregate->name = assign_strptr( name );
+        newnode->type->aggInst->params = params;
+        return newnode;
+}
 DeclarationNode *DeclarationNode::newTypeDecl( std::string *name, DeclarationNode *typeParams ) {
     DeclarationNode *newnode = new DeclarationNode;
     newnode->name = assign_strptr( name );
     newnode->type = new TypeData( TypeData::Symbolic );
     newnode->type->symbolic->isTypedef = false;
     newnode->type->symbolic->params = typeParams;
     newnode->type->symbolic->name = newnode->name;
     return newnode;
+        DeclarationNode *newnode = new DeclarationNode;
+        newnode->name = assign_strptr( name );
+        newnode->type = new TypeData( TypeData::Symbolic );
+        newnode->type->symbolic->isTypedef = false;
+        newnode->type->symbolic->params = typeParams;
+        newnode->type->symbolic->name = newnode->name;
+        return newnode;
+}
 DeclarationNode *DeclarationNode::newPointer( DeclarationNode *qualifiers ) {
     DeclarationNode *newnode = new DeclarationNode;
     newnode->type = new TypeData( TypeData::Pointer );
     return newnode->addQualifiers( qualifiers );
+        DeclarationNode *newnode = new DeclarationNode;
+        newnode->type = new TypeData( TypeData::Pointer );
+        return newnode->addQualifiers( qualifiers );
+}
 DeclarationNode *DeclarationNode::newArray( ExpressionNode *size, DeclarationNode *qualifiers, bool isStatic ) {
     DeclarationNode *newnode = new DeclarationNode;
     newnode->type = new TypeData( TypeData::Array );
     newnode->type->array->dimension = size;
     newnode->type->array->isStatic = isStatic;
     newnode->type->array->isVarLen = false;
     return newnode->addQualifiers( qualifiers );
+        DeclarationNode *newnode = new DeclarationNode;
+        newnode->type = new TypeData( TypeData::Array );
+        newnode->type->array->dimension = size;
+        newnode->type->array->isStatic = isStatic;
+        newnode->type->array->isVarLen = false;
+        return newnode->addQualifiers( qualifiers );
+}
 DeclarationNode *DeclarationNode::newVarArray( DeclarationNode *qualifiers ) {
     DeclarationNode *newnode = new DeclarationNode;
     newnode->type = new TypeData( TypeData::Array );
     newnode->type->array->dimension = 0;
     newnode->type->array->isStatic = false;
     newnode->type->array->isVarLen = true;
     return newnode->addQualifiers( qualifiers );
+        DeclarationNode *newnode = new DeclarationNode;
+        newnode->type = new TypeData( TypeData::Array );
+        newnode->type->array->dimension = 0;
+        newnode->type->array->isStatic = false;
+        newnode->type->array->isVarLen = true;
+        return newnode->addQualifiers( qualifiers );
+}
 DeclarationNode *DeclarationNode::newBitfield( ExpressionNode *size ) {
     DeclarationNode *newnode = new DeclarationNode;
     newnode->bitfieldWidth = size;
     return newnode;
+        DeclarationNode *newnode = new DeclarationNode;
+        newnode->bitfieldWidth = size;
+        return newnode;
+}
 DeclarationNode *DeclarationNode::newTuple( DeclarationNode *members ) {
     DeclarationNode *newnode = new DeclarationNode;
     newnode->type = new TypeData( TypeData::Tuple );
     newnode->type->tuple->members = members;
     return newnode;
+        DeclarationNode *newnode = new DeclarationNode;
+        newnode->type = new TypeData( TypeData::Tuple );
+        newnode->type->tuple->members = members;
+        return newnode;
+}
 DeclarationNode *DeclarationNode::newTypeof( ExpressionNode *expr ) {
     DeclarationNode *newnode = new DeclarationNode;
     newnode->type = new TypeData( TypeData::Typeof );
     newnode->type->typeexpr->expr = expr;
     return newnode;
+        DeclarationNode *newnode = new DeclarationNode;
+        newnode->type = new TypeData( TypeData::Typeof );
+        newnode->type->typeexpr->expr = expr;
+        return newnode;
+}
 DeclarationNode *DeclarationNode::newAttr( std::string *name, ExpressionNode *expr ) {
     DeclarationNode *newnode = new DeclarationNode;
     newnode->type = new TypeData( TypeData::Attr );
     newnode->type->attr->name = assign_strptr( name );
     newnode->type->attr->expr = expr;
     return newnode;
+        DeclarationNode *newnode = new DeclarationNode;
+        newnode->type = new TypeData( TypeData::Attr );
+        newnode->type->attr->name = assign_strptr( name );
+        newnode->type->attr->expr = expr;
+        return newnode;
+}
 DeclarationNode *DeclarationNode::newAttr( std::string *name, DeclarationNode *type ) {
     DeclarationNode *newnode = new DeclarationNode;
     newnode->type = new TypeData( TypeData::Attr );
     newnode->type->attr->name = assign_strptr( name );
     newnode->type->attr->type = type;
     return newnode;
+        DeclarationNode *newnode = new DeclarationNode;
+        newnode->type = new TypeData( TypeData::Attr );
+        newnode->type->attr->name = assign_strptr( name );
+        newnode->type->attr->type = type;
+        return newnode;
+}
 static void addQualifiersToType( TypeData *&src, TypeData *dst ) {
     if ( src && dst ) {
         if ( src->forall && dst->kind == TypeData::Function ) {
             if ( dst->forall ) {
                 dst->forall->appendList( src->forall );
             } else {
                 dst->forall = src->forall;
+            }
             src->forall = 0;
+        }
         if ( dst->base ) {
             addQualifiersToType( src, dst->base );
         } else if ( dst->kind == TypeData::Function ) {
             dst->base = src;
             src = 0;
         } else {
             dst->qualifiers.splice( dst->qualifiers.end(), src->qualifiers );
+        }
+    }
+}
+        if ( src && dst ) {
+                if ( src->forall && dst->kind == TypeData::Function ) {
+                        if ( dst->forall ) {
+                                dst->forall->appendList( src->forall );
+                        } else {
+                                dst->forall = src->forall;
+                        }
+                        src->forall = 0;
+                }
+                if ( dst->base ) {
+                        addQualifiersToType( src, dst->base );
+                } else if ( dst->kind == TypeData::Function ) {
+                        dst->base = src;
+                        src = 0;
+                } else {
+                        dst->qualifiers.splice( dst->qualifiers.end(), src->qualifiers );
+                }
+        }
+}
 DeclarationNode *DeclarationNode::addQualifiers( DeclarationNode *q ) {
+    if ( q ) {
+        storageClasses.splice( storageClasses.end(), q->storageClasses );
+        if ( q->type ) {
+            if ( ! type ) {
+                type = new TypeData;
+            }
+            addQualifiersToType( q->type, type );
+            if ( q->type && q->type->forall ) {
+                if ( type->forall ) {
+                    type->forall->appendList( q->type->forall );
+        if ( q ) {
+                storageClasses.splice( storageClasses.end(), q->storageClasses );
+                if ( q->type ) {
+                        if ( ! type ) {
+                                type = new TypeData;
+                        }
+                        addQualifiersToType( q->type, type );
+                        if ( q->type && q->type->forall ) {
+                                if ( type->forall ) {
+                                        type->forall->appendList( q->type->forall );
+                                } else {
+                                        type->forall = q->type->forall;
+                                }
+                                q->type->forall = 0;
+                        }
+                }
+        }
+        delete q;
+        return this;
+}
+DeclarationNode *DeclarationNode::copyStorageClasses( DeclarationNode *q ) {
+        storageClasses = q->storageClasses;
+        return this;
+}
+static void addTypeToType( TypeData *&src, TypeData *&dst ) {
+        if ( src && dst ) {
+                if ( src->forall && dst->kind == TypeData::Function ) {
+                        if ( dst->forall ) {
+                                dst->forall->appendList( src->forall );
+                        } else {
+                                dst->forall = src->forall;
+                        }
+                        src->forall = 0;
+                }
+                if ( dst->base ) {
+                        addTypeToType( src, dst->base );
                 } else {
+                    type->forall = q->type->forall;
+                }
+                q->type->forall = 0;
+            }
+        }
+    }
+    delete q;
+    return this;
+}
+DeclarationNode *DeclarationNode::copyStorageClasses( DeclarationNode *q ) {
+    storageClasses = q->storageClasses;
+    return this;
+}
+static void addTypeToType( TypeData *&src, TypeData *&dst ) {
+    if ( src && dst ) {
+        if ( src->forall && dst->kind == TypeData::Function ) {
+            if ( dst->forall ) {
+                dst->forall->appendList( src->forall );
+            } else {
+                dst->forall = src->forall;
+            }
+            src->forall = 0;
+        }
+        if ( dst->base ) {
+            addTypeToType( src, dst->base );
+        } else {
+            switch ( dst->kind ) {
+              case TypeData::Unknown:
+                src->qualifiers.splice( src->qualifiers.end(), dst->qualifiers );
+                dst = src;
+                src = 0;
+                        switch ( dst->kind ) {
+                          case TypeData::Unknown:
+                                src->qualifiers.splice( src->qualifiers.end(), dst->qualifiers );
+                                dst = src;
+                                src = 0;
+                                break;
+                          case TypeData::Basic:
+                                dst->qualifiers.splice( dst->qualifiers.end(), src->qualifiers );
+                                if ( src->kind != TypeData::Unknown ) {
+                                        assert( src->kind == TypeData::Basic );
+                                        dst->basic->modifiers.splice( dst->basic->modifiers.end(), src->basic->modifiers );
+                                        dst->basic->typeSpec.splice( dst->basic->typeSpec.end(), src->basic->typeSpec );
+                                }
+                                break;
+                          default:
+                                switch ( src->kind ) {
+                                  case TypeData::Aggregate:
+                                  case TypeData::Enum:
+                                        dst->base = new TypeData( TypeData::AggregateInst );
+                                        dst->base->aggInst->aggregate = src;
+                                        if ( src->kind == TypeData::Aggregate ) {
+                                                dst->base->aggInst->params = maybeClone( src->aggregate->actuals );
+                                        }
+                                        dst->base->qualifiers.splice( dst->base->qualifiers.end(), src->qualifiers );
+                                        src = 0;
+                                        break;
+                                  default:
+                                        if ( dst->forall ) {
+                                                dst->forall->appendList( src->forall );
+                                        } else {
+                                                dst->forall = src->forall;
+                                        }
+                                        src->forall = 0;
+                                        dst->base = src;
+                                        src = 0;
+                                }
+                        }
+                }
+        }
+}
+DeclarationNode *DeclarationNode::addType( DeclarationNode *o ) {
+        if ( o ) {
+                storageClasses.splice( storageClasses.end(), o->storageClasses );
+                if ( o->type ) {
+                        if ( ! type ) {
+                                if ( o->type->kind == TypeData::Aggregate || o->type->kind == TypeData::Enum ) {
+                                        type = new TypeData( TypeData::AggregateInst );
+                                        type->aggInst->aggregate = o->type;
+                                        if ( o->type->kind == TypeData::Aggregate ) {
+                                                type->aggInst->params = maybeClone( o->type->aggregate->actuals );
+                                        }
+                                        type->qualifiers.splice( type->qualifiers.end(), o->type->qualifiers );
+                                } else {
+                                        type = o->type;
+                                }
+                                o->type = 0;
+                        } else {
+                                addTypeToType( o->type, type );
+                        }
+                }
+                if ( o->bitfieldWidth ) {
+                        bitfieldWidth = o->bitfieldWidth;
+                }
+        }
+        delete o;
+        return this;
+}
+DeclarationNode *DeclarationNode::addTypedef() {
+        TypeData *newtype = new TypeData( TypeData::Symbolic );
+        newtype->symbolic->params = 0;
+        newtype->symbolic->isTypedef = true;
+        newtype->symbolic->name = name;
+        newtype->base = type;
+        type = newtype;
+        return this;
+}
+DeclarationNode *DeclarationNode::addAssertions( DeclarationNode* assertions ) {
+        assert( type );
+        switch ( type->kind ) {
+          case TypeData::Symbolic:
+                if ( type->symbolic->assertions ) {
+                        type->symbolic->assertions->appendList( assertions );
+                } else {
+                        type->symbolic->assertions = assertions;
+                }
                 break;
+              case TypeData::Basic:
+                dst->qualifiers.splice( dst->qualifiers.end(), src->qualifiers );
+                if ( src->kind != TypeData::Unknown ) {
+                    assert( src->kind == TypeData::Basic );
+                    dst->basic->modifiers.splice( dst->basic->modifiers.end(), src->basic->modifiers );
+                    dst->basic->typeSpec.splice( dst->basic->typeSpec.end(), src->basic->typeSpec );
+          case TypeData::Variable:
+                if ( type->variable->assertions ) {
+                        type->variable->assertions->appendList( assertions );
+                } else {
+                        type->variable->assertions = assertions;
+                }
                 break;
+              default:
+                switch ( src->kind ) {
+                  case TypeData::Aggregate:
+                  case TypeData::Enum:
+                    dst->base = new TypeData( TypeData::AggregateInst );
+                    dst->base->aggInst->aggregate = src;
+                    if ( src->kind == TypeData::Aggregate ) {
+                        dst->base->aggInst->params = maybeClone( src->aggregate->actuals );
+                    }
+                    dst->base->qualifiers.splice( dst->base->qualifiers.end(), src->qualifiers );
+                    src = 0;
+                    break;
+                  default:
+                    if ( dst->forall ) {
+                        dst->forall->appendList( src->forall );
+                    } else {
+                        dst->forall = src->forall;
+                    }
+                    src->forall = 0;
+                    dst->base = src;
+                    src = 0;
+                }
+            }
+        }
+    }
+}
+DeclarationNode *DeclarationNode::addType( DeclarationNode *o ) {
+    if ( o ) {
+        storageClasses.splice( storageClasses.end(), o->storageClasses );
+        if ( o->type ) {
+            if ( ! type ) {
+                if ( o->type->kind == TypeData::Aggregate || o->type->kind == TypeData::Enum ) {
+                    type = new TypeData( TypeData::AggregateInst );
+                    type->aggInst->aggregate = o->type;
+                    if ( o->type->kind == TypeData::Aggregate ) {
+                        type->aggInst->params = maybeClone( o->type->aggregate->actuals );
+                    }
+                    type->qualifiers.splice( type->qualifiers.end(), o->type->qualifiers );
+                } else {
+                    type = o->type;
+                }
+                o->type = 0;
+            } else {
+                addTypeToType( o->type, type );
+            }
+        }
+        if ( o->bitfieldWidth ) {
+            bitfieldWidth = o->bitfieldWidth;
+        }
+    }
+    delete o;
+    return this;
+}
+DeclarationNode *DeclarationNode::addTypedef() {
+    TypeData *newtype = new TypeData( TypeData::Symbolic );
+    newtype->symbolic->params = 0;
+    newtype->symbolic->isTypedef = true;
+    newtype->symbolic->name = name;
+    newtype->base = type;
+    type = newtype;
+    return this;
+}
+DeclarationNode *DeclarationNode::addAssertions( DeclarationNode* assertions ) {
+    assert( type );
+    switch ( type->kind ) {
+      case TypeData::Symbolic:
+        if ( type->symbolic->assertions ) {
+            type->symbolic->assertions->appendList( assertions );
+        } else {
+            type->symbolic->assertions = assertions;
+        }
+        break;
+      case TypeData::Variable:
+        if ( type->variable->assertions ) {
+            type->variable->assertions->appendList( assertions );
+        } else {
+            type->variable->assertions = assertions;
+        }
+        break;
+      default:
+        assert( false );
+    }
+    return this;
+          default:
+                assert( false );
+        }
+        return this;
+}
 DeclarationNode *DeclarationNode::addName( std::string* newname ) {
     name = assign_strptr( newname );
     return this;
+        name = assign_strptr( newname );
+        return this;
+}
 DeclarationNode *DeclarationNode::addBitfield( ExpressionNode *size ) {
     bitfieldWidth = size;
     return this;
+        bitfieldWidth = size;
+        return this;
+}
 DeclarationNode *DeclarationNode::addVarArgs() {
     assert( type );
     hasEllipsis = true;
     return this;
+        assert( type );
+        hasEllipsis = true;
+        return this;
+}
 DeclarationNode *DeclarationNode::addFunctionBody( StatementNode *body ) {
     assert( type );
     assert( type->kind == TypeData::Function );
     assert( type->function->body == 0 );
     type->function->body = body;
     type->function->hasBody = true;
     return this;
+        assert( type );
+        assert( type->kind == TypeData::Function );
+        assert( type->function->body == 0 );
+        type->function->body = body;
+        type->function->hasBody = true;
+        return this;
+}
 DeclarationNode *DeclarationNode::addOldDeclList( DeclarationNode *list ) {
     assert( type );
     assert( type->kind == TypeData::Function );
     assert( type->function->oldDeclList == 0 );
     type->function->oldDeclList = list;
     return this;
+        assert( type );
+        assert( type->kind == TypeData::Function );
+        assert( type->function->oldDeclList == 0 );
+        type->function->oldDeclList = list;
+        return this;
+}
 static void
 setBase( TypeData *&type, TypeData *newType ) {
     if ( type ) {
         TypeData *prevBase = type;
         TypeData *curBase = type->base;
         while( curBase != 0 ) {
             prevBase = curBase;
             curBase = curBase->base;
+        }
         prevBase->base = newType;
     } else {
         type = newType;
+    }
+        if ( type ) {
+                TypeData *prevBase = type;
+                TypeData *curBase = type->base;
+                while( curBase != 0 ) {
+                        prevBase = curBase;
+                        curBase = curBase->base;
+                }
+                prevBase->base = newType;
+        } else {
+                type = newType;
+        }
+}
 DeclarationNode *DeclarationNode::addPointer( DeclarationNode *p ) {
     if ( p ) {
         assert( p->type->kind == TypeData::Pointer );
         setBase( type, p->type );
         p->type = 0;
         delete p;
+    }
     return this;
+        if ( p ) {
+                assert( p->type->kind == TypeData::Pointer );
+                setBase( type, p->type );
+                p->type = 0;
+                delete p;
+        }
+        return this;
+}
 DeclarationNode *DeclarationNode::addArray( DeclarationNode *a ) {
     if ( a ) {
         assert( a->type->kind == TypeData::Array );
         setBase( type, a->type );
         a->type = 0;
         delete a;
+    }
     return this;
+        if ( a ) {
+                assert( a->type->kind == TypeData::Array );
+                setBase( type, a->type );
+                a->type = 0;
+                delete a;
+        }
+        return this;
+}
 DeclarationNode *DeclarationNode::addNewPointer( DeclarationNode *p ) {
+    if ( p ) {
+        assert( p->type->kind == TypeData::Pointer );
+        if ( p ) {
+                assert( p->type->kind == TypeData::Pointer );
+                if ( type ) {
+                        switch ( type->kind ) {
+                          case TypeData::Aggregate:
+                          case TypeData::Enum:
+                                p->type->base = new TypeData( TypeData::AggregateInst );
+                                p->type->base->aggInst->aggregate = type;
+                                if ( type->kind == TypeData::Aggregate ) {
+                                        p->type->base->aggInst->params = maybeClone( type->aggregate->actuals );
+                                }
+                                p->type->base->qualifiers.splice( p->type->base->qualifiers.end(), type->qualifiers );
+                                break;
+                          default:
+                                p->type->base = type;
+                        }
+                        type = 0;
+                }
+                delete this;
+                return p;
+        } else {
+                return this;
+        }
+}
+static TypeData *findLast( TypeData *a ) {
+        assert( a );
+        TypeData *cur = a;
+        while( cur->base ) {
+                cur = cur->base;
+        }
+        return cur;
+}
+DeclarationNode *DeclarationNode::addNewArray( DeclarationNode *a ) {
+        if ( a ) {
+                assert( a->type->kind == TypeData::Array );
+                TypeData *lastArray = findLast( a->type );
+                if ( type ) {
+                        switch ( type->kind ) {
+                          case TypeData::Aggregate:
+                          case TypeData::Enum:
+                                lastArray->base = new TypeData( TypeData::AggregateInst );
+                                lastArray->base->aggInst->aggregate = type;
+                                if ( type->kind == TypeData::Aggregate ) {
+                                        lastArray->base->aggInst->params = maybeClone( type->aggregate->actuals );
+                                }
+                                lastArray->base->qualifiers.splice( lastArray->base->qualifiers.end(), type->qualifiers );
+                                break;
+                          default:
+                                lastArray->base = type;
+                        }
+                        type = 0;
+                }
+                delete this;
+                return a;
+        } else {
+                return this;
+        }
+}
+DeclarationNode *DeclarationNode::addParamList( DeclarationNode *params ) {
+        TypeData *ftype = new TypeData( TypeData::Function );
+        ftype->function->params = params;
+        setBase( type, ftype );
+        return this;
+}
+static TypeData *addIdListToType( TypeData *type, DeclarationNode *ids ) {
         if ( type ) {
+            switch ( type->kind ) {
+              case TypeData::Aggregate:
+              case TypeData::Enum:
+                p->type->base = new TypeData( TypeData::AggregateInst );
+                p->type->base->aggInst->aggregate = type;
+                if ( type->kind == TypeData::Aggregate ) {
+                    p->type->base->aggInst->params = maybeClone( type->aggregate->actuals );
+                }
+                p->type->base->qualifiers.splice( p->type->base->qualifiers.end(), type->qualifiers );
+                break;
+              default:
+                p->type->base = type;
+            }
+            type = 0;
+        }
+        delete this;
+        return p;
+    } else {
+        return this;
+    }
+}
+static TypeData *findLast( TypeData *a ) {
+    assert( a );
+    TypeData *cur = a;
+    while( cur->base ) {
+        cur = cur->base;
+    }
+    return cur;
+}
+DeclarationNode *DeclarationNode::addNewArray( DeclarationNode *a ) {
+    if ( a ) {
+        assert( a->type->kind == TypeData::Array );
+        TypeData *lastArray = findLast( a->type );
+        if ( type ) {
+            switch ( type->kind ) {
+              case TypeData::Aggregate:
+              case TypeData::Enum:
+                lastArray->base = new TypeData( TypeData::AggregateInst );
+                lastArray->base->aggInst->aggregate = type;
+                if ( type->kind == TypeData::Aggregate ) {
+                    lastArray->base->aggInst->params = maybeClone( type->aggregate->actuals );
+                }
+                lastArray->base->qualifiers.splice( lastArray->base->qualifiers.end(), type->qualifiers );
+                break;
+              default:
+                lastArray->base = type;
+            }
+            type = 0;
+        }
+        delete this;
+        return a;
+    } else {
+        return this;
+    }
+}
+DeclarationNode *DeclarationNode::addParamList( DeclarationNode *params ) {
+    TypeData *ftype = new TypeData( TypeData::Function );
+    ftype->function->params = params;
+    setBase( type, ftype );
+    return this;
+}
+static TypeData *addIdListToType( TypeData *type, DeclarationNode *ids ) {
+    if ( type ) {
+        if ( type->kind != TypeData::Function ) {
+            type->base = addIdListToType( type->base, ids );
+                if ( type->kind != TypeData::Function ) {
+                        type->base = addIdListToType( type->base, ids );
+                } else {
+                        type->function->idList = ids;
+                }
+                return type;
         } else {
+            type->function->idList = ids;
+        }
+        return type;
+    } else {
+        TypeData *newtype = new TypeData( TypeData::Function );
+        newtype->function->idList = ids;
+        return newtype;
+    }
+}
+                TypeData *newtype = new TypeData( TypeData::Function );
+                newtype->function->idList = ids;
+                return newtype;
+        }
+}
 DeclarationNode *DeclarationNode::addIdList( DeclarationNode *ids ) {
     type = addIdListToType( type, ids );
     return this;
+        type = addIdListToType( type, ids );
+        return this;
+}
 DeclarationNode *DeclarationNode::addInitializer( InitializerNode *init ) {
     //assert
     initializer = init;
     return this;
+        //assert
+        initializer = init;
+        return this;
+}
 DeclarationNode *DeclarationNode::cloneBaseType( string *newName ) {
+    DeclarationNode *newnode = new DeclarationNode;
+    TypeData *srcType = type;
+    while( srcType->base ) {
+        srcType = srcType->base;
+    }
+    newnode->type = maybeClone( srcType );
+    if ( newnode->type->kind == TypeData::AggregateInst ) {
+        // don't duplicate members
+        if ( newnode->type->aggInst->aggregate->kind == TypeData::Enum ) {
+            delete newnode->type->aggInst->aggregate->enumeration->constants;
+            newnode->type->aggInst->aggregate->enumeration->constants = 0;
+        DeclarationNode *newnode = new DeclarationNode;
+        TypeData *srcType = type;
+        while( srcType->base ) {
+                srcType = srcType->base;
+        }
+        newnode->type = maybeClone( srcType );
+        if ( newnode->type->kind == TypeData::AggregateInst ) {
+                // don't duplicate members
+                if ( newnode->type->aggInst->aggregate->kind == TypeData::Enum ) {
+                        delete newnode->type->aggInst->aggregate->enumeration->constants;
+                        newnode->type->aggInst->aggregate->enumeration->constants = 0;
+                } else {
+                        assert( newnode->type->aggInst->aggregate->kind == TypeData::Aggregate );
+                        delete newnode->type->aggInst->aggregate->aggregate->members;
+                        newnode->type->aggInst->aggregate->aggregate->members = 0;
+                }
+        }
+        newnode->type->forall = maybeClone( type->forall );
+        newnode->storageClasses = storageClasses;
+        newnode->name = assign_strptr( newName );
+        return newnode;
+}
+DeclarationNode *DeclarationNode::cloneBaseType( DeclarationNode *o ) {
+        if ( o ) {
+                o->storageClasses.insert( o->storageClasses.end(), storageClasses.begin(), storageClasses.end() );
+                if ( type ) {
+                        TypeData *srcType = type;
+                        while( srcType->base ) {
+                                srcType = srcType->base;
+                        }
+                        TypeData *newType = srcType->clone();
+                        if ( newType->kind == TypeData::AggregateInst ) {
+                                // don't duplicate members
+                                if ( newType->aggInst->aggregate->kind == TypeData::Enum ) {
+                                        delete newType->aggInst->aggregate->enumeration->constants;
+                                        newType->aggInst->aggregate->enumeration->constants = 0;
+                                } else {
+                                        assert( newType->aggInst->aggregate->kind == TypeData::Aggregate );
+                                        delete newType->aggInst->aggregate->aggregate->members;
+                                        newType->aggInst->aggregate->aggregate->members = 0;
+                                }
+                        }
+                        newType->forall = maybeClone( type->forall );
+                        if ( ! o->type ) {
+                                o->type = newType;
+                        } else {
+                                addTypeToType( newType, o->type );
+                                delete newType;
+                        }
+                }
+        }
+        return o;
+}
+DeclarationNode *DeclarationNode::cloneType( string *newName ) {
+        DeclarationNode *newnode = new DeclarationNode;
+        newnode->type = maybeClone( type );
+        newnode->storageClasses = storageClasses;
+        newnode->name = assign_strptr( newName );
+        return newnode;
+}
+DeclarationNode *DeclarationNode::cloneType( DeclarationNode *o ) {
+        if ( o ) {
+                o->storageClasses.insert( o->storageClasses.end(), storageClasses.begin(), storageClasses.end() );
+                if ( type ) {
+                        TypeData *newType = type->clone();
+                        if ( ! o->type ) {
+                                o->type = newType;
+                        } else {
+                                addTypeToType( newType, o->type );
+                                delete newType;
+                        }
+                }
+        }
+        return o;
+}
+DeclarationNode *DeclarationNode::appendList( DeclarationNode *node ) {
+        if ( node != 0 ) {
+                set_link( node );
+        }
+        return this;
+}
+DeclarationNode *DeclarationNode::extractAggregate() const {
+        if ( type ) {
+                TypeData *ret = type->extractAggregate();
+                if ( ret ) {
+                        DeclarationNode *newnode = new DeclarationNode;
+                        newnode->type = ret;
+                        return newnode;
+                } else {
+                        return 0;
+                }
         } else {
+            assert( newnode->type->aggInst->aggregate->kind == TypeData::Aggregate );
+            delete newnode->type->aggInst->aggregate->aggregate->members;
+            newnode->type->aggInst->aggregate->aggregate->members = 0;
+        }
+    }
+    newnode->type->forall = maybeClone( type->forall );
+    newnode->storageClasses = storageClasses;
+    newnode->name = assign_strptr( newName );
+    return newnode;
+}
+DeclarationNode *DeclarationNode::cloneBaseType( DeclarationNode *o ) {
+    if ( o ) {
+        o->storageClasses.insert( o->storageClasses.end(), storageClasses.begin(), storageClasses.end() );
+        if ( type ) {
+            TypeData *srcType = type;
+            while( srcType->base ) {
+                srcType = srcType->base;
+            }
+            TypeData *newType = srcType->clone();
+            if ( newType->kind == TypeData::AggregateInst ) {
+                // don't duplicate members
+                if ( newType->aggInst->aggregate->kind == TypeData::Enum ) {
+                    delete newType->aggInst->aggregate->enumeration->constants;
+                    newType->aggInst->aggregate->enumeration->constants = 0;
+                } else {
+                    assert( newType->aggInst->aggregate->kind == TypeData::Aggregate );
+                    delete newType->aggInst->aggregate->aggregate->members;
+                    newType->aggInst->aggregate->aggregate->members = 0;
+                }
+            }
+            newType->forall = maybeClone( type->forall );
+            if ( ! o->type ) {
+                o->type = newType;
+            } else {
+                addTypeToType( newType, o->type );
+                delete newType;
+            }
+        }
+    }
+    return o;
+}
+DeclarationNode *DeclarationNode::cloneType( string *newName ) {
+    DeclarationNode *newnode = new DeclarationNode;
+    newnode->type = maybeClone( type );
+    newnode->storageClasses = storageClasses;
+    newnode->name = assign_strptr( newName );
+    return newnode;
+}
+DeclarationNode *DeclarationNode::cloneType( DeclarationNode *o ) {
+    if ( o ) {
+        o->storageClasses.insert( o->storageClasses.end(), storageClasses.begin(), storageClasses.end() );
+        if ( type ) {
+            TypeData *newType = type->clone();
+            if ( ! o->type ) {
+                o->type = newType;
+            } else {
+                addTypeToType( newType, o->type );
+                delete newType;
+            }
+        }
+    }
+    return o;
+}
+DeclarationNode *DeclarationNode::appendList( DeclarationNode *node ) {
+    if ( node != 0 ) {
+        set_link( node );
+    }
+    return this;
+}
+DeclarationNode *DeclarationNode::extractAggregate() const {
+    if ( type ) {
+        TypeData *ret = type->extractAggregate();
+        if ( ret ) {
+            DeclarationNode *newnode = new DeclarationNode;
+            newnode->type = ret;
+            return newnode;
+        } else {
+            return 0;
+        }
+    } else {
+        return 0;
+    }
+                return 0;
+        }
+}
 void buildList( const DeclarationNode *firstNode, std::list< Declaration* > &outputList ) {
+    SemanticError errors;
+    std::back_insert_iterator< std::list< Declaration* > > out( outputList );
+    const DeclarationNode *cur = firstNode;
+    while( cur ) {
+        try {
+            if ( DeclarationNode *extr = cur->extractAggregate() ) {
+                // handle the case where a structure declaration is contained within an object or type
+                // declaration
+                Declaration *decl = extr->build();
+                if ( decl ) {
+                   *out++ = decl;
+                }
+            }
+            Declaration *decl = cur->build();
+            if ( decl ) {
+                *out++ = decl;
+            }
+        } catch( SemanticError &e ) {
+            errors.append( e );
+        }
+        cur = dynamic_cast< DeclarationNode* >( cur->get_link() );
+    }
+    if ( ! errors.isEmpty() ) {
+        throw errors;
+    }
+        SemanticError errors;
+        std::back_insert_iterator< std::list< Declaration* > > out( outputList );
+        const DeclarationNode *cur = firstNode;
+        while( cur ) {
+                try {
+                        if ( DeclarationNode *extr = cur->extractAggregate() ) {
+                                // handle the case where a structure declaration is contained within an object or type declaration
+                                Declaration *decl = extr->build();
+                                if ( decl ) {
+                                        *out++ = decl;
+                                }
+                        }
+                        Declaration *decl = cur->build();
+                        if ( decl ) {
+                                *out++ = decl;
+                        }
+                } catch( SemanticError &e ) {
+                        errors.append( e );
+                }
+                cur = dynamic_cast< DeclarationNode* >( cur->get_link() );
+        }
+        if ( ! errors.isEmpty() ) {
+                throw errors;
+        }
+}
 void buildList( const DeclarationNode *firstNode, std::list< DeclarationWithType* > &outputList ) {
     SemanticError errors;
     std::back_insert_iterator< std::list< DeclarationWithType* > > out( outputList );
     const DeclarationNode *cur = firstNode;
     while( cur ) {
         try {
+        SemanticError errors;
+        std::back_insert_iterator< std::list< DeclarationWithType* > > out( outputList );
+        const DeclarationNode *cur = firstNode;
+        while( cur ) {
+                try {
 ///       if ( DeclarationNode *extr = cur->extractAggregate() ) {
 ///     // handle the case where a structure declaration is contained within an object or type
 …
 ///     }
 ///       }
             Declaration *decl = cur->build();
             if ( decl ) {
                 if ( DeclarationWithType *dwt = dynamic_cast< DeclarationWithType* >( decl ) ) {
                    *out++ = dwt;
                 } else if ( StructDecl *agg = dynamic_cast< StructDecl* >( decl ) ) {
                     StructInstType *inst = new StructInstType( Type::Qualifiers(), agg->get_name() );
                     *out++ = new ObjectDecl( "", Declaration::NoStorageClass, linkage, 0, inst, 0 );
                     delete agg;
                 } else if ( UnionDecl *agg = dynamic_cast< UnionDecl* >( decl ) ) {
                     UnionInstType *inst = new UnionInstType( Type::Qualifiers(), agg->get_name() );
                     *out++ = new ObjectDecl( "", Declaration::NoStorageClass, linkage, 0, inst, 0 );
+                }
+            }
         } catch( SemanticError &e ) {
             errors.append( e );
+        }
         cur = dynamic_cast< DeclarationNode* >( cur->get_link() );
+    }
     if ( ! errors.isEmpty() ) {
         throw errors;
+    }
+                        Declaration *decl = cur->build();
+                        if ( decl ) {
+                                if ( DeclarationWithType *dwt = dynamic_cast< DeclarationWithType* >( decl ) ) {
+                                        *out++ = dwt;
+                                } else if ( StructDecl *agg = dynamic_cast< StructDecl* >( decl ) ) {
+                                        StructInstType *inst = new StructInstType( Type::Qualifiers(), agg->get_name() );
+                                        *out++ = new ObjectDecl( "", Declaration::NoStorageClass, linkage, 0, inst, 0 );
+                                        delete agg;
+                                } else if ( UnionDecl *agg = dynamic_cast< UnionDecl* >( decl ) ) {
+                                        UnionInstType *inst = new UnionInstType( Type::Qualifiers(), agg->get_name() );
+                                        *out++ = new ObjectDecl( "", Declaration::NoStorageClass, linkage, 0, inst, 0 );
+                                }
+                        }
+                } catch( SemanticError &e ) {
+                        errors.append( e );
+                }
+                cur = dynamic_cast< DeclarationNode* >( cur->get_link() );
+        }
+        if ( ! errors.isEmpty() ) {
+                throw errors;
+        }
+}
 void buildTypeList( const DeclarationNode *firstNode, std::list< Type* > &outputList ) {
     SemanticError errors;
     std::back_insert_iterator< std::list< Type* > > out( outputList );
     const DeclarationNode *cur = firstNode;
     while( cur ) {
         try {
            *out++ = cur->buildType();
         } catch( SemanticError &e ) {
             errors.append( e );
+        }
         cur = dynamic_cast< DeclarationNode* >( cur->get_link() );
+    }
     if ( ! errors.isEmpty() ) {
         throw errors;
+    }
+        SemanticError errors;
+        std::back_insert_iterator< std::list< Type* > > out( outputList );
+        const DeclarationNode *cur = firstNode;
+        while( cur ) {
+                try {
+                        *out++ = cur->buildType();
+                } catch( SemanticError &e ) {
+                        errors.append( e );
+                }
+                cur = dynamic_cast< DeclarationNode* >( cur->get_link() );
+        }
+        if ( ! errors.isEmpty() ) {
+                throw errors;
+        }
+}
 Declaration *DeclarationNode::build() const {
+    if ( ! type ) {
+        if ( buildInline() ) {
+            throw SemanticError( "invalid inline specification in declaration of ", this );
+        if ( ! type ) {
+                if ( buildInline() ) {
+                        throw SemanticError( "invalid inline specification in declaration of ", this );
+                } else {
+                        return new ObjectDecl( name, buildStorageClass(), linkage, maybeBuild< Expression >( bitfieldWidth ), 0, maybeBuild< Initializer >( initializer ) );
+                }
         } else {
+            return new ObjectDecl( name, buildStorageClass(), linkage, maybeBuild< Expression >( bitfieldWidth ), 0, maybeBuild< Initializer >( initializer ) );
+        }
+    } else {
+        Declaration *newDecl = type->buildDecl( name, buildStorageClass(), maybeBuild< Expression >( bitfieldWidth ), buildInline(), linkage, maybeBuild< Initializer >(initializer) );
+        return newDecl;
+    }
+    // we should never get here
+    assert( false );
+    return 0;
+                Declaration *newDecl = type->buildDecl( name, buildStorageClass(), maybeBuild< Expression >( bitfieldWidth ), buildInline(), linkage, maybeBuild< Initializer >(initializer) );
+                return newDecl;
+        }
+        // we should never get here
+        assert( false );
+        return 0;
+}
 Type *DeclarationNode::buildType() const {
     assert( type );
+        assert( type );
     switch ( type->kind ) {
       case TypeData::Enum:
         return new EnumInstType( type->buildQualifiers(), type->enumeration->name );
       case TypeData::Aggregate: {
           ReferenceToType *ret;
           switch ( type->aggregate->kind ) {
             case DeclarationNode::Struct:
               ret = new StructInstType( type->buildQualifiers(), type->aggregate->name );
               break;
             case DeclarationNode::Union:
               ret = new UnionInstType( type->buildQualifiers(), type->aggregate->name );
               break;
             case DeclarationNode::Context:
               ret = new ContextInstType( type->buildQualifiers(), type->aggregate->name );
               break;
             default:
               assert( false );
           } // switch
           buildList( type->aggregate->actuals, ret->get_parameters() );
           return ret;
+      }
       case TypeData::Symbolic: {
           TypeInstType *ret = new TypeInstType( type->buildQualifiers(), type->symbolic->name, false );
           buildList( type->symbolic->actuals, ret->get_parameters() );
           return ret;
+      }
       default:
         return type->build();
     } // switch
+        switch ( type->kind ) {
+          case TypeData::Enum:
+                return new EnumInstType( type->buildQualifiers(), type->enumeration->name );
+          case TypeData::Aggregate: {
+                  ReferenceToType *ret;
+                  switch ( type->aggregate->kind ) {
+                        case DeclarationNode::Struct:
+                          ret = new StructInstType( type->buildQualifiers(), type->aggregate->name );
+                          break;
+                        case DeclarationNode::Union:
+                          ret = new UnionInstType( type->buildQualifiers(), type->aggregate->name );
+                          break;
+                        case DeclarationNode::Context:
+                          ret = new ContextInstType( type->buildQualifiers(), type->aggregate->name );
+                          break;
+                        default:
+                          assert( false );
+                  } // switch
+                  buildList( type->aggregate->actuals, ret->get_parameters() );
+                  return ret;
+          }
+          case TypeData::Symbolic: {
+                  TypeInstType *ret = new TypeInstType( type->buildQualifiers(), type->symbolic->name, false );
+                  buildList( type->symbolic->actuals, ret->get_parameters() );
+                  return ret;
+          }
+          default:
+                return type->build();
+        } // switch
+}
 Declaration::StorageClass DeclarationNode::buildStorageClass() const {
     static const Declaration::StorageClass scMap[] = {
         Declaration::Extern,
         Declaration::Static,
         Declaration::Auto,
         Declaration::Register,
         Declaration::Inline,
         Declaration::Fortran
     };
+        static const Declaration::StorageClass scMap[] = {
+                Declaration::Extern,
+                Declaration::Static,
+                Declaration::Auto,
+                Declaration::Register,
+                Declaration::Inline,
+                Declaration::Fortran
+        };
+    Declaration::StorageClass ret = Declaration::NoStorageClass;
+    for ( std::list< StorageClass >::const_iterator i = storageClasses.begin(); i != storageClasses.end(); ++i ) {
+        assert( unsigned( *i ) < sizeof( scMap ) / sizeof( scMap[0] ) );
+        if ( *i == Inline ) continue;
+        if ( ret == Declaration::NoStorageClass ) {
+            ret = scMap[ *i ];
+        Declaration::StorageClass ret = Declaration::NoStorageClass;
+        for ( std::list< StorageClass >::const_iterator i = storageClasses.begin(); i != storageClasses.end(); ++i ) {
+                assert( unsigned( *i ) < sizeof( scMap ) / sizeof( scMap[0] ) );
+                if ( *i == Inline ) continue;
+                if ( ret == Declaration::NoStorageClass ) {
+                        ret = scMap[ *i ];
+                } else {
+                        throw SemanticError( "invalid combination of storage classes in declaration of ", this );
+                }
+        }
+        return ret;
+}
+bool DeclarationNode::buildInline() const {
+        std::list< StorageClass >::const_iterator first = std::find( storageClasses.begin(), storageClasses.end(), Inline );
+        if ( first == storageClasses.end() ) {
+                return false;
         } else {
+            throw SemanticError( "invalid combination of storage classes in declaration of ", this );
+        }
+    }
+    return ret;
+}
+bool DeclarationNode::buildInline() const {
+    std::list< StorageClass >::const_iterator first = std::find( storageClasses.begin(), storageClasses.end(), Inline );
+    if ( first == storageClasses.end() ) {
+                std::list< StorageClass >::const_iterator next = std::find( ++first, storageClasses.end(), Inline );
+                if ( next == storageClasses.end() ) {
+                        return true;
+                } else {
+                        throw SemanticError( "duplicate inline specification in declaration of ", this );
+                }
+        }
+        // we should never get here
         return false;
+    } else {
+        std::list< StorageClass >::const_iterator next = std::find( ++first, storageClasses.end(), Inline );
+        if ( next == storageClasses.end() ) {
+            return true;
+        } else {
+            throw SemanticError( "duplicate inline specification in declaration of ", this );
+        }
+    }
+    // we should never get here
+    return false;
+}
+}
+// Local Variables: //
+// tab-width: 4 //
+// mode: c++ //
+// compile-command: "make install" //
+// End: //

translator/Parser/ExpressionNode.cc

-                      rb8508a2
+                      rb87a5ed
+//
+// 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.
+//
+// ExpressionNode.cc --
+//
+// Author           : Rodolfo G. Esteves
+// Created On       : Sat May 16 13:17:07 2015
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Sat May 16 13:19:35 2015
+// Update Count     : 2
+//
 #include <cassert>
 #include <cctype>
 …
 ExpressionNode::ExpressionNode( string *name_) : ParseNode( *name_ ), argName( 0 ) {
     delete name_;
+        delete name_;
+}
 ExpressionNode::ExpressionNode( const ExpressionNode &other ) : ParseNode( other.name ) {
     if ( other.argName ) {
         argName = other.argName->clone();
     } else {
         argName = 0;
     } // if
+        if ( other.argName ) {
+                argName = other.argName->clone();
+        } else {
+                argName = 0;
+        } // if
+}
 ExpressionNode * ExpressionNode::set_asArgName( std::string *aName ) {
     argName = new VarRefNode( aName );
     return this;
+        argName = new VarRefNode( aName );
+        return this;
+}
 ExpressionNode * ExpressionNode::set_asArgName( ExpressionNode *aDesignator ) {
     argName = aDesignator;
     return this;
+        argName = aDesignator;
+        return this;
+}
 void ExpressionNode::printDesignation( std::ostream &os, int indent ) const {
     if ( argName ) {
         os << string(' ', indent ) << "(designated by:  ";
         argName->printOneLine( os, indent );
         os << ")" << std::endl;
     } // if
+        if ( argName ) {
+                os << string(' ', indent ) << "(designated by:  ";
+                argName->printOneLine( os, indent );
+                os << ")" << std::endl;
+        } // if
+}
 …
 NullExprNode *NullExprNode::clone() const {
     return new NullExprNode();
+        return new NullExprNode();
+}
 void NullExprNode::print( std::ostream & os, int indent ) const {
     printDesignation( os );
     os << "null expression";
+        printDesignation( os );
+        os << "null expression";
+}
 void NullExprNode::printOneLine( std::ostream & os, int indent ) const {
     printDesignation( os );
     os << "null";
+        printDesignation( os );
+        os << "null";
+}
 Expression *NullExprNode::build() const {
     return 0;
+        return 0;
+}
 CommaExprNode *ExpressionNode::add_to_list( ExpressionNode *exp ){
     return new CommaExprNode( this, exp );
+        return new CommaExprNode( this, exp );
+}
 …
 ConstantNode::ConstantNode( Type t, string *inVal ) : type( t ), sign( true ), longs(0), size(0) {
     if ( inVal ) {
         value = *inVal;
         delete inVal;
     } else {
         value = "";
     } // if
     classify( value );
+}
 ConstantNode::ConstantNode( const ConstantNode &other )
     : ExpressionNode( other ), type( other.type ), value( other.value ), sign( other.sign ), base( other.base ), longs( other.longs ), size( other.size ) {
+        if ( inVal ) {
+                value = *inVal;
+                delete inVal;
+        } else {
+                value = "";
+        } // if
+        classify( value );
+}
+ConstantNode::ConstantNode( const ConstantNode &other ) : ExpressionNode( other ), type( other.type ), value( other.value ), sign( other.sign ),
+                                                                                                                  base( other.base ), longs( other.longs ), size( other.size ) {
+}
 // for some reason, std::tolower doesn't work as an argument to std::transform in g++ 3.1
 inline char tolower_hack( char c ) {
     return std::tolower( c );
+        return std::tolower( c );
+}
 void ConstantNode::classify( std::string &str ){
+    switch ( type ){
+      case Integer:
+      case Float:
+        {
+            std::string sfx("");
+            char c;
+            int i = str.length() - 1;
+            while ( i >= 0 && !isxdigit( c = str.at( i--)) )
+                sfx += c;
+            value = str.substr( 0, i + 2 );
+            // get rid of underscores
+            value.erase( remove( value.begin(), value.end(), '_'), value.end());
+            std::transform( sfx.begin(), sfx.end(), sfx.begin(), tolower_hack );
+            if ( sfx.find("ll") != string::npos ){
+                longs = 2;
+            } else if ( sfx.find("l") != string::npos ){
+                longs = 1;
+            } // if
+            assert(( longs >= 0) && ( longs <= 2));
+            if ( sfx.find("u") != string::npos )
+                sign = false;
+            break;
+        switch ( type ){
+          case Integer:
+          case Float:
+                {
+                        std::string sfx("");
+                        char c;
+                        int i = str.length() - 1;
+                        while ( i >= 0 && !isxdigit( c = str.at( i--)) )
+                                sfx += c;
+                        value = str.substr( 0, i + 2 );
+                        // get rid of underscores
+                        value.erase( remove( value.begin(), value.end(), '_'), value.end());
+                        std::transform( sfx.begin(), sfx.end(), sfx.begin(), tolower_hack );
+                        if ( sfx.find("ll") != string::npos ){
+                                longs = 2;
+                        } else if ( sfx.find("l") != string::npos ){
+                                longs = 1;
+                        } // if
+                        assert(( longs >= 0) && ( longs <= 2));
+                        if ( sfx.find("u") != string::npos )
+                                sign = false;
+                        break;
+                }
+          case Character:
+                {
+                        // remove underscores from hex and oct escapes
+                        if ( str.substr(1,2) == "\\x")
+                                value.erase( remove( value.begin(), value.end(), '_'), value.end());
+                        break;
+                }
+          default:
+                // shouldn't be here
+                ;
+        }
+      case Character:
+        {
+            // remove underscores from hex and oct escapes
+            if ( str.substr(1,2) == "\\x")
+                value.erase( remove( value.begin(), value.end(), '_'), value.end());
+            break;
+}
+ConstantNode::Type ConstantNode::get_type( void ) const {
+        return type;
+}
+ConstantNode *ConstantNode::append( std::string *newValue ) {
+        if ( newValue ) {
+                if ( type == String ){
+                        std::string temp = *newValue;
+                        value.resize( value.size() - 1 );
+                        value += newValue->substr(1, newValue->size());
+                } else
+                        value += *newValue;
+                delete newValue;
+        } // if
+        return this;
+}
+void ConstantNode::printOneLine( std::ostream &os, int indent ) const {
+        os << string( indent, ' ');
+        printDesignation( os );
+        switch ( type ) {
+                /* integers */
+          case Integer:
+                os << value ;
+                break;
+          case Float:
+                os << value ;
+                break;
+          case Character:
+                os << "'" << value << "'";
+                break;
+          case String:
+                os << '"' << value << '"';
+                break;
+        }
+      default:
+        // shouldn't be here
+        ;
+    }
+}
+ConstantNode::Type ConstantNode::get_type( void ) const {
+    return type;
+}
+ConstantNode *ConstantNode::append( std::string *newValue ) {
+    if ( newValue ) {
+        if ( type == String ){
+            std::string temp = *newValue;
+            value.resize( value.size() - 1 );
+            value += newValue->substr(1, newValue->size());
+        } else
+            value += *newValue;
+        delete newValue;
+    } // if
+    return this;
+}
+void ConstantNode::printOneLine( std::ostream &os, int indent ) const {
+    os << string( indent, ' ');
+    printDesignation( os );
+    switch ( type ) {
+        /* integers */
+      case Integer:
+        os << value ;
+        break;
+      case Float:
+        os << value ;
+        break;
+      case Character:
+        os << "'" << value << "'";
+        break;
+      case String:
+        os << '"' << value << '"';
+        break;
+    }
+    os << ' ';
+        os << ' ';
+}
 void ConstantNode::print( std::ostream &os, int indent ) const {
     printOneLine( os, indent );
     os << endl;
+        printOneLine( os, indent );
+        os << endl;
+}
 Expression *ConstantNode::build() const {
     ::Type::Qualifiers q;
     BasicType *bt;
     switch ( get_type()){
       case Integer:
         /* Cfr. standard 6.4.4.1 */
         //bt.set_kind( BasicType::SignedInt );
         bt = new BasicType( q, BasicType::SignedInt );
         break;
       case Float:
         bt = new BasicType( q, BasicType::Float );
         break;
       case Character:
         bt = new BasicType( q, BasicType::Char );
         break;
       case String:
         // string should probably be a primitive type
         ArrayType *at;
         std::string value = get_value();
         at = new ArrayType( q, new BasicType( q, BasicType::Char ),
                            new ConstantExpr( Constant( new BasicType( q, BasicType::SignedInt ),
                                                        toString( value.size() - 1 ) ) ),  // account for '\0'
                            false, false );
         return new ConstantExpr( Constant( at, value ), maybeBuild< Expression >( get_argName() ) );
+    }
     return new ConstantExpr(  Constant( bt, get_value()),  maybeBuild< Expression >( get_argName() ) );
+        ::Type::Qualifiers q;
+        BasicType *bt;
+        switch ( get_type()){
+          case Integer:
+                /* Cfr. standard 6.4.4.1 */
+                //bt.set_kind( BasicType::SignedInt );
+                bt = new BasicType( q, BasicType::SignedInt );
+                break;
+          case Float:
+                bt = new BasicType( q, BasicType::Float );
+                break;
+          case Character:
+                bt = new BasicType( q, BasicType::Char );
+                break;
+          case String:
+                // string should probably be a primitive type
+                ArrayType *at;
+                std::string value = get_value();
+                at = new ArrayType( q, new BasicType( q, BasicType::Char ),
+                                                        new ConstantExpr( Constant( new BasicType( q, BasicType::SignedInt ),
+                                                                                                                toString( value.size() - 1 ) ) ),  // account for '\0'
+                                                        false, false );
+                return new ConstantExpr( Constant( at, value ), maybeBuild< Expression >( get_argName() ) );
+        }
+        return new ConstantExpr(  Constant( bt, get_value()),  maybeBuild< Expression >( get_argName() ) );
+}
 …
 Expression *VarRefNode::build() const {
     return new NameExpr( get_name(), maybeBuild< Expression >( get_argName() ) );
+        return new NameExpr( get_name(), maybeBuild< Expression >( get_argName() ) );
+}
 void VarRefNode::printOneLine( std::ostream &os, int indent ) const {
     printDesignation( os );
     os << get_name() << ' ';
+        printDesignation( os );
+        os << get_name() << ' ';
+}
 void VarRefNode::print( std::ostream &os, int indent ) const {
     printDesignation( os );
     os << '\r' << string( indent, ' ') << "Referencing: ";
     os << "Variable: " << get_name();
     os << endl;
+        printDesignation( os );
+        os << '\r' << string( indent, ' ') << "Referencing: ";
+        os << "Variable: " << get_name();
+        os << endl;
+}
 …
 OperatorNode::Type OperatorNode::get_type( void ) const{
     return type;
+        return type;
+}
 void OperatorNode::printOneLine( std::ostream &os, int indent ) const {
     printDesignation( os );
     os << OpName[ type ] << ' ';
+        printDesignation( os );
+        os << OpName[ type ] << ' ';
+}
 void OperatorNode::print( std::ostream &os, int indent ) const{
     printDesignation( os );
     os << '\r' << string( indent, ' ') << "Operator: " << OpName[type] << endl;
     return;
+        printDesignation( os );
+        os << '\r' << string( indent, ' ') << "Operator: " << OpName[type] << endl;
+        return;
+}
 std::string OperatorNode::get_typename( void ) const{
     return string( OpName[ type ]);
+        return string( OpName[ type ]);
+}
 const char *OperatorNode::OpName[] = {
     "TupleC",  "Comma", "TupleFieldSel",// "TuplePFieldSel", //n-adic
     // triadic
     "Cond",   "NCond",
     // diadic
     "SizeOf",      "AlignOf", "Attr", "CompLit", "Plus",    "Minus",   "Mul",     "Div",     "Mod",      "Or",
     "And",       "BitOr",   "BitAnd",  "Xor",     "Cast",    "LShift",  "RShift",  "LThan",   "GThan",
     "LEThan",    "GEThan", "Eq",      "Neq",     "Assign",  "MulAssn", "DivAssn", "ModAssn", "PlusAssn",
     "MinusAssn", "LSAssn", "RSAssn",  "AndAssn", "ERAssn",  "OrAssn",  "Index",   "FieldSel","PFieldSel",
     "Range",
     // monadic
     "UnPlus", "UnMinus", "AddressOf", "PointTo", "Neg", "BitNeg", "Incr", "IncrPost", "Decr", "DecrPost", "LabelAddress"
+        "TupleC",  "Comma", "TupleFieldSel",// "TuplePFieldSel", //n-adic
+        // triadic
+        "Cond",   "NCond",
+        // diadic
+        "SizeOf",      "AlignOf", "Attr", "CompLit", "Plus",    "Minus",   "Mul",     "Div",     "Mod",      "Or",
+        "And",       "BitOr",   "BitAnd",  "Xor",     "Cast",    "LShift",  "RShift",  "LThan",   "GThan",
+        "LEThan",    "GEThan", "Eq",      "Neq",     "Assign",  "MulAssn", "DivAssn", "ModAssn", "PlusAssn",
+        "MinusAssn", "LSAssn", "RSAssn",  "AndAssn", "ERAssn",  "OrAssn",  "Index",   "FieldSel","PFieldSel",
+        "Range",
+        // monadic
+        "UnPlus", "UnMinus", "AddressOf", "PointTo", "Neg", "BitNeg", "Incr", "IncrPost", "Decr", "DecrPost", "LabelAddress"
 };
 …
 CompositeExprNode::CompositeExprNode( ExpressionNode *f, ExpressionNode *args ):
     function( f ), arguments( args ) {
+        function( f ), arguments( args ) {
+}
 CompositeExprNode::CompositeExprNode( ExpressionNode *f, ExpressionNode *arg1, ExpressionNode *arg2):
     function( f ), arguments( arg1) {
     arguments->set_link( arg2);
+        function( f ), arguments( arg1) {
+        arguments->set_link( arg2);
+}
 CompositeExprNode::CompositeExprNode( const CompositeExprNode &other ) : ExpressionNode( other ), function( maybeClone( other.function ) ) {
     ParseNode *cur = other.arguments;
     while ( cur ) {
         if ( arguments ) {
             arguments->set_link( cur->clone() );
         } else {
             arguments = ( ExpressionNode*)cur->clone();
         } // if
         cur = cur->get_link();
+    }
+        ParseNode *cur = other.arguments;
+        while ( cur ) {
+                if ( arguments ) {
+                        arguments->set_link( cur->clone() );
+                } else {
+                        arguments = ( ExpressionNode*)cur->clone();
+                } // if
+                cur = cur->get_link();
+        }
+}
 CompositeExprNode::~CompositeExprNode() {
     delete function;
     delete arguments;
+        delete function;
+        delete arguments;
+}
 // the names that users use to define operator functions
 static const char *opFuncName[] = {
     "",  "", "",
     "",   "",
     // diadic
     "",   "", "", "", "?+?",    "?-?",   "?*?",     "?/?",     "?%?",     "",       "",
     "?|?",  "?&?",  "?^?",     "",    "?<<?",  "?>>?",  "?<?",   "?>?",    "?<=?",
     "?>=?", "?==?",      "?!=?",     "?=?",  "?*=?", "?/=?", "?%=?", "?+=?", "?-=?",
     "?<<=?", "?>>=?",  "?&=?", "?^=?",  "?|=?",  "?[?]",   "","","Range",
     // monadic
     "+?", "-?", "", "*?", "!?", "~?", "++?", "?++", "--?", "?--", "LabAddress"
+        "",  "", "",
+        "",   "",
+        // diadic
+        "",   "", "", "", "?+?",    "?-?",   "?*?",     "?/?",     "?%?",     "",       "",
+        "?|?",  "?&?",  "?^?",     "",    "?<<?",  "?>>?",  "?<?",   "?>?",    "?<=?",
+        "?>=?", "?==?",      "?!=?",     "?=?",  "?*=?", "?/=?", "?%=?", "?+=?", "?-=?",
+        "?<<=?", "?>>=?",  "?&=?", "?^=?",  "?|=?",  "?[?]",   "","","Range",
+        // monadic
+        "+?", "-?", "", "*?", "!?", "~?", "++?", "?++", "--?", "?--", "LabAddress"
 };
 …
 Expression *CompositeExprNode::build() const {
     OperatorNode *op;
     std::list<Expression *> args;
     buildList( get_args(), args );
     if ( ! ( op = dynamic_cast<OperatorNode *>( function )) ) {
         // a function as opposed to an operator
         return new UntypedExpr( function->build(), args, maybeBuild< Expression >( get_argName() ));
     } else {
         switch ( op->get_type()){
           case OperatorNode::Incr:
           case OperatorNode::Decr:
           case OperatorNode::IncrPost:
           case OperatorNode::DecrPost:
           case OperatorNode::Assign:
           case OperatorNode::MulAssn:
           case OperatorNode::DivAssn:
           case OperatorNode::ModAssn:
           case OperatorNode::PlusAssn:
           case OperatorNode::MinusAssn:
           case OperatorNode::LSAssn:
           case OperatorNode::RSAssn:
           case OperatorNode::AndAssn:
           case OperatorNode::ERAssn:
           case OperatorNode::OrAssn:
             // the rewrite rules for these expressions specify that the first argument has its address taken
             assert( !args.empty() );
             args.front() = new AddressExpr( args.front() );
             break;
           default:
             /* do nothing */
+            ;
+        }
         switch ( op->get_type() ) {
           case OperatorNode::Incr:
           case OperatorNode::Decr:
           case OperatorNode::IncrPost:
           case OperatorNode::DecrPost:
           case OperatorNode::Assign:
           case OperatorNode::MulAssn:
           case OperatorNode::DivAssn:
           case OperatorNode::ModAssn:
           case OperatorNode::PlusAssn:
           case OperatorNode::MinusAssn:
           case OperatorNode::LSAssn:
           case OperatorNode::RSAssn:
           case OperatorNode::AndAssn:
           case OperatorNode::ERAssn:
           case OperatorNode::OrAssn:
           case OperatorNode::Plus:
           case OperatorNode::Minus:
           case OperatorNode::Mul:
           case OperatorNode::Div:
           case OperatorNode::Mod:
           case OperatorNode::BitOr:
           case OperatorNode::BitAnd:
           case OperatorNode::Xor:
           case OperatorNode::LShift:
           case OperatorNode::RShift:
           case OperatorNode::LThan:
           case OperatorNode::GThan:
           case OperatorNode::LEThan:
           case OperatorNode::GEThan:
           case OperatorNode::Eq:
           case OperatorNode::Neq:
           case OperatorNode::Index:
           case OperatorNode::Range:
           case OperatorNode::UnPlus:
           case OperatorNode::UnMinus:
           case OperatorNode::PointTo:
           case OperatorNode::Neg:
           case OperatorNode::BitNeg:
           case OperatorNode::LabelAddress:
             return new UntypedExpr( new NameExpr( opFuncName[ op->get_type() ] ), args );
           case OperatorNode::AddressOf:
             assert( args.size() == 1 );
             assert( args.front() );
             return new AddressExpr( args.front() );
           case OperatorNode::Cast:
+            {
                 TypeValueNode * arg = dynamic_cast<TypeValueNode *>( get_args());
                 assert( arg );
                 DeclarationNode *decl_node = arg->get_decl();
                 ExpressionNode *expr_node = dynamic_cast<ExpressionNode *>( arg->get_link());
                 Type *targetType = decl_node->buildType();
                 if ( dynamic_cast< VoidType* >( targetType ) ) {
                     delete targetType;
                     return new CastExpr( expr_node->build(), maybeBuild< Expression >( get_argName() ) );
                 } else {
                     return new CastExpr( expr_node->build(),targetType, maybeBuild< Expression >( get_argName() ) );
                 } // if
+            }
           case OperatorNode::FieldSel:
+            {
                 assert( args.size() == 2 );
                 NameExpr *member = dynamic_cast<NameExpr *>( args.back());
                 // TupleExpr *memberTup = dynamic_cast<TupleExpr *>( args.back());
                 if ( member != 0 ) {
                     UntypedMemberExpr *ret = new UntypedMemberExpr( member->get_name(), args.front());
                     delete member;
                     return ret;
                 /* else if ( memberTup != 0 )
+                   {
                    UntypedMemberExpr *ret = new UntypedMemberExpr( memberTup->get_name(), args.front());
                    delete member;
                    return ret;
                    } */
                 } else
                     assert( false );
+            }
           case OperatorNode::PFieldSel:
+            {
                 assert( args.size() == 2 );
                 NameExpr *member = dynamic_cast<NameExpr *>( args.back());  // modify for Tuples   xxx
                 assert( member != 0 );
                 UntypedExpr *deref = new UntypedExpr( new NameExpr( "*?" ) );
                 deref->get_args().push_back( args.front() );
                 UntypedMemberExpr *ret = new UntypedMemberExpr( member->get_name(), deref );
                 delete member;
                 return ret;
+            }
           case OperatorNode::AlignOf:
           case OperatorNode::SizeOf:
+            {
+        OperatorNode *op;
+        std::list<Expression *> args;
+        buildList( get_args(), args );
+        if ( ! ( op = dynamic_cast<OperatorNode *>( function )) ) {
+                // a function as opposed to an operator
+                return new UntypedExpr( function->build(), args, maybeBuild< Expression >( get_argName() ));
+        } else {
+                switch ( op->get_type()){
+                  case OperatorNode::Incr:
+                  case OperatorNode::Decr:
+                  case OperatorNode::IncrPost:
+                  case OperatorNode::DecrPost:
+                  case OperatorNode::Assign:
+                  case OperatorNode::MulAssn:
+                  case OperatorNode::DivAssn:
+                  case OperatorNode::ModAssn:
+                  case OperatorNode::PlusAssn:
+                  case OperatorNode::MinusAssn:
+                  case OperatorNode::LSAssn:
+                  case OperatorNode::RSAssn:
+                  case OperatorNode::AndAssn:
+                  case OperatorNode::ERAssn:
+                  case OperatorNode::OrAssn:
+                        // the rewrite rules for these expressions specify that the first argument has its address taken
+                        assert( !args.empty() );
+                        args.front() = new AddressExpr( args.front() );
+                        break;
+                  default:
+                        /* do nothing */
+                        ;
+                }
+                switch ( op->get_type() ) {
+                  case OperatorNode::Incr:
+                  case OperatorNode::Decr:
+                  case OperatorNode::IncrPost:
+                  case OperatorNode::DecrPost:
+                  case OperatorNode::Assign:
+                  case OperatorNode::MulAssn:
+                  case OperatorNode::DivAssn:
+                  case OperatorNode::ModAssn:
+                  case OperatorNode::PlusAssn:
+                  case OperatorNode::MinusAssn:
+                  case OperatorNode::LSAssn:
+                  case OperatorNode::RSAssn:
+                  case OperatorNode::AndAssn:
+                  case OperatorNode::ERAssn:
+                  case OperatorNode::OrAssn:
+                  case OperatorNode::Plus:
+                  case OperatorNode::Minus:
+                  case OperatorNode::Mul:
+                  case OperatorNode::Div:
+                  case OperatorNode::Mod:
+                  case OperatorNode::BitOr:
+                  case OperatorNode::BitAnd:
+                  case OperatorNode::Xor:
+                  case OperatorNode::LShift:
+                  case OperatorNode::RShift:
+                  case OperatorNode::LThan:
+                  case OperatorNode::GThan:
+                  case OperatorNode::LEThan:
+                  case OperatorNode::GEThan:
+                  case OperatorNode::Eq:
+                  case OperatorNode::Neq:
+                  case OperatorNode::Index:
+                  case OperatorNode::Range:
+                  case OperatorNode::UnPlus:
+                  case OperatorNode::UnMinus:
+                  case OperatorNode::PointTo:
+                  case OperatorNode::Neg:
+                  case OperatorNode::BitNeg:
+                  case OperatorNode::LabelAddress:
+                        return new UntypedExpr( new NameExpr( opFuncName[ op->get_type() ] ), args );
+                  case OperatorNode::AddressOf:
+                        assert( args.size() == 1 );
+                        assert( args.front() );
+                        return new AddressExpr( args.front() );
+                  case OperatorNode::Cast:
+                        {
+                                TypeValueNode * arg = dynamic_cast<TypeValueNode *>( get_args());
+                                assert( arg );
+                                DeclarationNode *decl_node = arg->get_decl();
+                                ExpressionNode *expr_node = dynamic_cast<ExpressionNode *>( arg->get_link());
+                                Type *targetType = decl_node->buildType();
+                                if ( dynamic_cast< VoidType* >( targetType ) ) {
+                                        delete targetType;
+                                        return new CastExpr( expr_node->build(), maybeBuild< Expression >( get_argName() ) );
+                                } else {
+                                        return new CastExpr( expr_node->build(),targetType, maybeBuild< Expression >( get_argName() ) );
+                                } // if
+                        }
+                  case OperatorNode::FieldSel:
+                        {
+                                assert( args.size() == 2 );
+                                NameExpr *member = dynamic_cast<NameExpr *>( args.back());
+                                // TupleExpr *memberTup = dynamic_cast<TupleExpr *>( args.back());
+                                if ( member != 0 ) {
+                                        UntypedMemberExpr *ret = new UntypedMemberExpr( member->get_name(), args.front());
+                                        delete member;
+                                        return ret;
+                                        /* else if ( memberTup != 0 )
+                                           {
+                                           UntypedMemberExpr *ret = new UntypedMemberExpr( memberTup->get_name(), args.front());
+                                           delete member;
+                                           return ret;
+                                           } */
+                                } else
+                                        assert( false );
+                        }
+                  case OperatorNode::PFieldSel:
+                        {
+                                assert( args.size() == 2 );
+                                NameExpr *member = dynamic_cast<NameExpr *>( args.back());  // modify for Tuples   xxx
+                                assert( member != 0 );
+                                UntypedExpr *deref = new UntypedExpr( new NameExpr( "*?" ) );
+                                deref->get_args().push_back( args.front() );
+                                UntypedMemberExpr *ret = new UntypedMemberExpr( member->get_name(), deref );
+                                delete member;
+                                return ret;
+                        }
+                  case OperatorNode::AlignOf:
+                  case OperatorNode::SizeOf:
+                        {
 ///     bool isSizeOf = ( op->get_type() == OperatorNode::SizeOf );
+                if ( TypeValueNode * arg = dynamic_cast<TypeValueNode *>( get_args()) ) {
+                    return new SizeofExpr( arg->get_decl()->buildType());
+                } else {
+                    return new SizeofExpr( args.front());
+                } // if
+            }
+          case OperatorNode::Attr:
+            {
+                VarRefNode *var = dynamic_cast<VarRefNode *>( get_args());
+                assert( var );
+                if ( !get_args()->get_link() ) {
+                    return new AttrExpr( var->build(), ( Expression*)0);
+                } else if ( TypeValueNode * arg = dynamic_cast<TypeValueNode *>( get_args()->get_link()) ) {
+                    return new AttrExpr( var->build(), arg->get_decl()->buildType());
+                } else {
+                    return new AttrExpr( var->build(), args.back());
+                } // if
+            }
+          case OperatorNode::CompLit:
+            throw UnimplementedError( "C99 compound literals" );
+            // the short-circuited operators
+          case OperatorNode::Or:
+          case OperatorNode::And:
+            assert( args.size() == 2);
+            return new LogicalExpr( notZeroExpr( args.front() ), notZeroExpr( args.back() ), ( op->get_type() == OperatorNode::And ) );
+          case OperatorNode::Cond:
+            {
+                assert( args.size() == 3);
+                std::list< Expression* >::const_iterator i = args.begin();
+                Expression *arg1 = notZeroExpr( *i++ );
+                Expression *arg2 = *i++;
+                Expression *arg3 = *i++;
+                return new ConditionalExpr( arg1, arg2, arg3 );
+            }
+          case OperatorNode::NCond:
+            throw UnimplementedError( "GNU 2-argument conditional expression" );
+          case OperatorNode::Comma:
+            {
+                assert( args.size() == 2);
+                std::list< Expression* >::const_iterator i = args.begin();
+                Expression *ret = *i++;
+                while ( i != args.end() ) {
+                    ret = new CommaExpr( ret, *i++ );
+                }
+                return ret;
+            }
+            // Tuples
+          case OperatorNode::TupleC:
+            {
+                TupleExpr *ret = new TupleExpr();
+                std::copy( args.begin(), args.end(), back_inserter( ret->get_exprs() ) );
+                return ret;
+            }
+          default:
+            // shouldn't happen
+            return 0;
+        }
+    }
+}
+void CompositeExprNode::printOneLine( std::ostream &os, int indent ) const {
+    printDesignation( os );
+    os << "( ";
+    function->printOneLine( os, indent );
+    for ( ExpressionNode *cur = arguments; cur != 0; cur = dynamic_cast< ExpressionNode* >( cur->get_link() ) ) {
+        cur->printOneLine( os, indent );
+    }
+    os << ") ";
+}
+void CompositeExprNode::print( std::ostream &os, int indent ) const {
+    printDesignation( os );
+    os << '\r' << string( indent, ' ') << "Application of: " << endl;
+    function->print( os, indent + ParseNode::indent_by );
+    os << '\r' << string( indent, ' ') ;
+    if ( arguments ) {
+        os << "... on arguments: " << endl;
+        arguments->printList( os, indent + ParseNode::indent_by );
+    } else
+        os << "... on no arguments: " << endl;
+}
+void CompositeExprNode::set_function( ExpressionNode *f ){
+    function = f;
+}
+void CompositeExprNode::set_args( ExpressionNode *args ){
+    arguments = args;
+}
+ExpressionNode *CompositeExprNode::get_function( void ) const {
+    return function;
+}
+ExpressionNode *CompositeExprNode::get_args( void ) const {
+    return arguments;
+}
+void CompositeExprNode::add_arg( ExpressionNode *arg ){
+    if ( arguments )
+        arguments->set_link( arg );
+    else
+        set_args( arg );
+}
+CommaExprNode::CommaExprNode(): CompositeExprNode( new OperatorNode( OperatorNode::Comma )) {}
+CommaExprNode::CommaExprNode( ExpressionNode *exp ) : CompositeExprNode( new OperatorNode( OperatorNode::Comma ), exp ) {
+}
+CommaExprNode::CommaExprNode( ExpressionNode *exp1, ExpressionNode *exp2) : CompositeExprNode( new OperatorNode( OperatorNode::Comma ), exp1, exp2) {
+}
+CommaExprNode *CommaExprNode::add_to_list( ExpressionNode *exp ){
+    add_arg( exp );
+    return this;
+}
+CommaExprNode::CommaExprNode( const CommaExprNode &other ) : CompositeExprNode( other ) {
+}
+ValofExprNode::ValofExprNode( StatementNode *s ): body( s ) {}
+ValofExprNode::ValofExprNode( const ValofExprNode &other ) : ExpressionNode( other ), body( maybeClone( body ) ) {
+}
+ValofExprNode::~ValofExprNode() {
+    delete body;
+}
+void ValofExprNode::print( std::ostream &os, int indent ) const {
+    printDesignation( os );
+    os << string( indent, ' ') << "Valof Expression:" << std::endl;
+    get_body()->print( os, indent + 4);
+}
+void ValofExprNode::printOneLine( std::ostream &, int indent ) const {
+    assert( false );
+}
+Expression *ValofExprNode::build() const {
+    return new UntypedValofExpr ( get_body()->build(), maybeBuild< Expression >( get_argName() ) );
+}
+ForCtlExprNode::ForCtlExprNode( ParseNode *init_, ExpressionNode *cond, ExpressionNode *incr ) throw ( SemanticError ) : condition( cond ), change( incr ) {
+    if ( init_ == 0 )
+        init = 0;
+    else {
+        DeclarationNode *decl;
+        ExpressionNode *exp;
+        if (( decl = dynamic_cast<DeclarationNode *>( init_)) != 0)
+            init = new StatementNode( decl );
+        else if (( exp = dynamic_cast<ExpressionNode *>( init_)) != 0)
+            init = new StatementNode( StatementNode::Exp, exp );
+        else
+            throw SemanticError("Error in for control expression");
+    }
+}
+ForCtlExprNode::ForCtlExprNode( const ForCtlExprNode &other )
+    : ExpressionNode( other ), init( maybeClone( other.init ) ), condition( maybeClone( other.condition ) ), change( maybeClone( other.change ) ) {
+}
+ForCtlExprNode::~ForCtlExprNode(){
+    delete init;
+    delete condition;
+    delete change;
+}
+Expression *ForCtlExprNode::build() const {
+    // this shouldn't be used!
+    assert( false );
+    return 0;
+}
+void ForCtlExprNode::print( std::ostream &os, int indent ) const{
+    os << string( indent,' ') << "For Control Expression -- : " << endl;
+    os << "\r" << string( indent + 2,' ') << "initialization: ";
+    if ( init != 0)
+        init->print( os, indent + 4);
+    os << "\n\r" << string( indent + 2,' ') << "condition: ";
+    if ( condition != 0)
+        cond