Changeset bdd516a

Timestamp:

Apr 28, 2015, 4:21:36 PM (10 years ago)

Author:

Peter A. Buhr <pabuhr@…>

Branches:

ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, ctor, deferred_resn, demangler, enum, forall-pointer-decay, gc_noraii, jacob/cs343-translation, jenkins-sandbox, master, memory, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, string, with_gc

Children:

42e2ad7

Parents:

ad17ba6a

Message:

fixed sizeof type variable, find lowest cost alternative for sizeof expression, removed unused classes, added compiler flag, remove temporary file for -CFA, formatting

Files:

• COPYING (deleted)
• LICENSE (added)
• driver/cc1.cc (modified) (12 diffs)
• driver/cpp.cc (modified) (8 diffs)
• libcfa/prelude.cf (modified) (3 diffs)
• libcfa/prototypes.awk (modified) (1 diff)
• translator/CodeGen/GenType.cc (modified) (2 diffs)
• translator/GenPoly/Box.cc (modified) (1 diff)
• translator/GenPoly/ScrubTyVars.cc (modified) (1 diff)
• translator/GenPoly/ScrubTyVars.h (modified) (2 diffs)
• translator/InitTweak/InitModel.h (modified) (1 diff)
• translator/Parser/DeclarationNode.cc (modified) (4 diffs)
• translator/Parser/ExpressionNode.cc (modified) (40 diffs)
• translator/Parser/InitializerNode.cc (modified) (1 diff)
• translator/Parser/ParseNode.cc (modified) (1 diff)
• translator/Parser/ParseNode.h (modified) (5 diffs)
• translator/Parser/TypeData.cc (modified) (1 diff)
• translator/Parser/TypeData.h (modified) (1 diff)
• translator/Parser/cfa.y (modified) (3 diffs)
• translator/Parser/parseutility.cc (modified) (2 diffs)
• translator/Parser/parseutility.h (modified) (2 diffs)
• translator/ResolvExpr/AlternativeFinder.cc (modified) (1 diff)
• translator/ResolvExpr/Resolver.cc (modified) (4 diffs)
• translator/SymTab/IdTable.cc (modified) (3 diffs)
• translator/SymTab/IdTable.h (modified) (2 diffs)
• translator/SymTab/Indexer.cc (modified) (3 diffs)
• translator/SymTab/Indexer.h (modified) (2 diffs)
• translator/SymTab/Mangler.cc (modified) (1 diff)
• translator/SymTab/Validate.cc (modified) (1 diff)
• translator/SynTree/Initializer.cc (modified) (1 diff)
• translator/SynTree/Initializer.h (modified) (1 diff)
• translator/SynTree/Mutator.cc (modified) (1 diff)
• translator/SynTree/Mutator.h (modified) (1 diff)
• translator/SynTree/SynTree.h (modified) (1 diff)
• translator/SynTree/Type.cc (modified) (1 diff)
• translator/SynTree/Type.h (modified) (9 diffs)
• translator/SynTree/Visitor.cc (modified) (1 diff)
• translator/SynTree/Visitor.h (modified) (1 diff)
• translator/Tests/Parser/Constant0-1.c (modified) (2 diffs)
• translator/examples/constants.c (added)
• translator/examples/control_structures.c (added)
• translator/examples/includes.c (modified) (1 diff)
• translator/examples/min.c (modified) (1 diff)
• translator/examples/square.c (modified) (1 diff)
• translator/examples/sum.c (modified) (3 diffs)
• translator/main.cc (modified) (4 diffs)

driver/cc1.cc

@@ -8 +8 @@
 // Created On       : Fri Aug 26 14:23:51 2005
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sat Jan 10 14:16:06 2015
-// Update Count     : 15
+// Last Modified On : Mon Apr 27 23:11:52 2015
+// Update Count     : 39
 //
 
@@ -34 +34 @@
 string D__CFA_FLAGPREFIX__( "-D__CFA_FLAG__=" );
 
+char tmpname[] = P_tmpdir "/CFAXXXXXX";
+int tmpfilefd = -1;
+
 
 bool prefix( string arg, string pre ) {
@@ -69 +72 @@
     } // 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
 
 
@@ -89 +109 @@
     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
@@ -116 +139 @@
                 i += 1;                                 // and the argument
 
-            // strip cfa flags controlling cpp step
-
+            // 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;
@@ -123 +151 @@
                 i += 1;                                 // and the argument
                 CFA_flag = true;
-            } 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 ( prefix( arg, D__CFA_FLAGPREFIX__ ) ) {
                 uargs[nuargs] = ( *new string( arg.substr( D__CFA_FLAGPREFIX__.size() ) ) ).c_str();
@@ -233 +256 @@
     // Create a temporary file to store output of the C preprocessor.
 
-    char tmpname[] = P_tmpdir "/CFAXXXXXX";
-    int tmpfile = mkstemp( tmpname );
-    if ( tmpfile == -1 ) {
+    tmpfilefd = mkstemp( tmpname );
+    if ( tmpfilefd == -1 ) {
         perror( "CFA Translator error: cpp level, mkstemp" );
         exit( EXIT_FAILURE );
@@ -241 +263 @@
 
 #ifdef __DEBUG_H__
-    cerr << "tmpname:" << tmpname << " tmpfile:" << tmpfile << endl;
+    cerr << "tmpname:" << tmpname << " tmpfilefd:" << tmpfilefd << endl;
 #endif // __DEBUG_H__
 
@@ -280 +302 @@
 
     if ( WIFSIGNALED(code) != 0 ) {                     // child failed ?
-        unlink( tmpname );                              // remove tmpname
+        rmtmpfile();                                    // remove tmpname
         cerr << "CFA Translator error: cpp failed with signal " << WTERMSIG(code) << endl;
         exit( EXIT_FAILURE );
@@ -286 +308 @@
 
     if ( WEXITSTATUS(code) != 0 ) {                     // child error ?
-        unlink( tmpname );                              // remove tmpname
+        rmtmpfile();                                    // remove tmpname
         exit( WEXITSTATUS( code ) );                    // do not continue
     } // if
@@ -293 +315 @@
     // output.  Otherwise, run the cfa-cpp preprocessor on the temporary file and save the result into the output file.
 
-    if ( CFA_flag || fork() == 0 ) {                    // conditional fork ?
+    if ( fork() == 0 ) {                                // child runs CFA
         uargs[0] = ( *new string( bprefix + "/cfa-cpp" ) ).c_str();
 
@@ -330 +352 @@
 
     // Must unlink here because file must exist across execvp.
-    if ( unlink( tmpname ) == -1 ) {
-        perror( "CFA Translator error: cpp level, unlink" );
-        exit( EXIT_FAILURE );
-    } // if
+    rmtmpfile();                                        // remove tmpname
 
     if ( WIFSIGNALED(code) ) {                          // child failed ?

driver/cpp.cc

@@ -8 +8 @@
 // Created On       : Thu Aug 29 12:24:06 2002
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sat Dec  6 08:31:49 2014
-// Update Count     : 51
+// Last Modified On : Tue Apr 21 07:23:38 2015
+// Update Count     : 52
 // 
 
@@ -218 +218 @@
     if ( cpp_flag && CFA_flag ) {
         cerr << argv[0] << " Error cannot use -E and -CFA flags together." << endl;
-        exit( -1 );
+        exit( EXIT_FAILURE );
     } // if
 
@@ -234 +234 @@
             if ( freopen( cpp_out.c_str(), "w", stdout ) == NULL ) { // redirect stdout if not -E
                 cerr << argv[0] << ": Error can't write to " << cpp_out << endl;
-                exit( -1 );
+                exit( EXIT_FAILURE );
             } // if
 
@@ -274 +274 @@
         execvp( args[0], (char *const *)args );         // should not return
         perror( "CFA translator error: cpp level, exec" );
-        exit( -1 );
+        exit( EXIT_FAILURE );
     } // if
 
@@ -282 +282 @@
         if ( freopen( tmpfile, "w", stdout ) == NULL) { // redirect output to tmpfile
             cerr << argv[0] << ": Error can't write to " << tmpfile << endl;
-            exit( -1 );
+            exit( EXIT_FAILURE );
         } // if
 
@@ -308 +308 @@
         execvp( args[0], (char *const *)args );         // should not return
         perror( "CFA translator error: cpp level, exec" );
-        exit( -1 );
+        exit( EXIT_FAILURE );
     } // if
 
@@ -316 +316 @@
         unlink( tmpfile );
         cerr << "CFA translator error: cpp failed with signal " << WTERMSIG(code) << endl;
-        exit( -1 );
+        exit( EXIT_FAILURE );
     } // if
 
@@ -357 +357 @@
     wait( &code );                                      // wait for child to finish
 
-    unlink( tmpfile );
+    if ( unlink( tmpfile ) == -1 ) {
+        cerr << "CFA translator error: cfa-cpp failed " << errno << " to remove temporary file \"" << tmpfile << "\"" << endl;
+        exit( EXIT_FAILURE );
+    } // if
 
     if ( WIFSIGNALED(code) != 0 ) {                     // child completed successfully ?
         cerr << "CFA translator error: cfa-cpp failed with signal " << WTERMSIG(code) << endl;
-        exit( -1 );
+        exit( EXIT_FAILURE );
     } // if
 
     if ( CFA_flag ) {                                   // -CFA flag ?
-        exit( -1 );                                     // tell gcc not to go any further
+        exit( EXIT_FAILURE );                           // tell gcc not to go any further
     } else {
         exit( WEXITSTATUS(code) );

libcfa/prelude.cf

@@ -8 +8 @@
 // Created On       : Sat Nov 29 07:23:41 2014
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Mon Jan 19 22:20:57 2015
-// Update Count     : 51
+// Last Modified On : Wed Mar 18 11:36:59 2015
+// Update Count     : 69
 //
 
@@ -35 +35 @@
 // ------------------------------------------------------------
 
-_Bool                   ?++( _Bool * ),                         ?--( _Bool * );
-signed int              ?++( signed int * ),                    ?--( signed int * );
-unsigned int            ?++( unsigned int * ),                  ?--( unsigned int * );
-signed long int         ?++( signed long int * ),               ?--( signed long int * );
-unsigned long int       ?++( unsigned long int * ),             ?--( unsigned long int * );
-signed long long int    ?++( signed long long int * ),          ?--( signed long long int * );
-unsigned long long int  ?++( unsigned long long int * ),        ?--( unsigned long long int * );
-float                   ?++( float * ),                         ?--( float * );
-double                  ?++( double * ),                        ?--( double * );
-long double             ?++( long double * ),                   ?--( long double * );
-float _Complex          ?++( float _Complex * ),                ?--( float _Complex * );
-double _Complex         ?++( double _Complex * ),               ?--( double _Complex * );
-long double _Complex    ?++( long double _Complex * ),          ?--( long double _Complex * );
+_Bool                   ?++( _Bool * ),                         ?++( volatile _Bool * );
+_Bool                   ?--( _Bool * ),                         ?--( volatile _Bool * );
+unsigned char           ?++( unsigned char * ),                 ?++( volatile unsigned char * );
+signed int              ?++( signed int * ),                    ?++( volatile signed int * );
+signed int              ?--( signed int * ),                    ?--( volatile signed int * );
+unsigned int            ?++( unsigned int * ),                  ?++( volatile unsigned int * );
+unsigned int            ?--( unsigned int * ),                  ?--( volatile unsigned int * );
+signed long int         ?++( signed long int * ),               ?++( volatile signed long int * );
+signed long int         ?--( signed long int * ),               ?--( volatile signed long int * );
+unsigned long int       ?++( unsigned long int * ),             ?++( volatile unsigned long int * );
+unsigned long int       ?--( unsigned long int * ),             ?--( volatile unsigned long int * );
+signed long long int    ?++( signed long long int * ),          ?++( volatile signed long long int * );
+signed long long int    ?--( signed long long int * ),          ?--( volatile signed long long int * );
+unsigned long long int  ?++( unsigned long long int * ),        ?++( volatile unsigned long long int * );
+unsigned long long int  ?--( unsigned long long int * ),        ?--( volatile unsigned long long int * );
+float                   ?++( float * ),                         ?++( volatile float * );
+float                   ?--( float * ),                         ?--( volatile float * );
+double                  ?++( double * ),                        ?++( volatile double * );
+double                  ?--( double * ),                        ?--( volatile double * );
+long double             ?++( long double * ),                   ?++( volatile long double * );
+long double             ?--( long double * ),                   ?--( volatile long double * );
+float _Complex          ?++( float _Complex * ),                ?++( volatile float _Complex * );
+float _Complex          ?--( float _Complex * ),                ?--( volatile float _Complex * );
+double _Complex         ?++( double _Complex * ),               ?++( volatile double _Complex * );
+double _Complex         ?--( double _Complex * ),               ?--( volatile double _Complex * );
+long double _Complex    ?++( long double _Complex * ),          ?++( volatile long double _Complex * );
+long double _Complex    ?--( long double _Complex * ),          ?--( volatile long double _Complex * );
 
 forall( type T ) T *                     ?++(                T ** );
@@ -203 +217 @@
 signed int ?<?( _Bool, _Bool ),                         ?<=?( _Bool, _Bool ),
            ?>?( _Bool, _Bool ),                         ?>=?( _Bool, _Bool );
+signed int ?<?( unsigned char, unsigned char ),         ?<=?( unsigned char, unsigned char ),
+           ?>?( unsigned char, unsigned char ),         ?>=?( unsigned char, unsigned char );
 signed int ?<?( signed int, signed int ),               ?<=?( signed int, signed int ),
            ?>?( signed int, signed int ),               ?>=?( signed int, signed int );

libcfa/prototypes.awk

@@ +1 @@
+# http://llvm.org/svn/llvm-project/cfe/trunk/include/clang/Basic/Builtins.def
+
 BEGIN {
     FS = "("

translator/CodeGen/GenType.cc

@@ -74 +74 @@
         if ( qualifiers.isRestrict ) {
             os << "__restrict ";
+        } // if
+        if ( qualifiers.isAtomic ) {
+            os << "_Atomic ";
         } // if
         if ( isVarLen ) {
@@ -180 +183 @@
             typeString = "__restrict " + typeString;
         } // if
+        if ( type->get_isAtomic() ) {
+            typeString = "_Atomic " + typeString;
+        } // if
     }
 } // namespace CodeGen

translator/GenPoly/Box.cc

@@ -772 +772 @@
         Expression *Pass1::mutate( AddressExpr *addrExpr ) {
             assert( !addrExpr->get_arg()->get_results().empty() );
-            mutateExpression( addrExpr->get_arg() );
+            addrExpr->set_arg( mutateExpression( addrExpr->get_arg() ) );
             if ( isPolyType( addrExpr->get_arg()->get_results().front(), env, scopeTyVars ) ) {
                 Expression *ret = addrExpr->get_arg();

translator/GenPoly/ScrubTyVars.cc

@@ -4 +4 @@
 #include "SynTree/Mutator.h"
 #include "SynTree/Type.h"
+#include "SynTree/Expression.h"
 
 
 namespace GenPoly {
+    Type * ScrubTyVars::mutate( TypeInstType *typeInst ) {
+        TyVarMap::const_iterator tyVar = tyVars.find( typeInst->get_name() );
+        if ( doAll || tyVar != tyVars.end() ) {
+            switch( tyVar->second ) {
+              case TypeDecl::Any:
+              case TypeDecl::Dtype:
+                {
+                    PointerType *ret = new PointerType( Type::Qualifiers(), new VoidType( typeInst->get_qualifiers() ) );
+                    delete typeInst;
+                    return ret;
+                }
+              case TypeDecl::Ftype:
+                delete typeInst;
+                return new PointerType( Type::Qualifiers(), new FunctionType( Type::Qualifiers(), true ) );
+            }
+        }
+        return typeInst;
+    }
 
-Type* 
-ScrubTyVars::mutate( TypeInstType *typeInst )
-{
-  TyVarMap::const_iterator tyVar = tyVars.find( typeInst->get_name() );
-  if( doAll || tyVar != tyVars.end() ) {
-    switch( tyVar->second ) {
-    case TypeDecl::Any:
-    case TypeDecl::Dtype:
-    {
-      PointerType *ret = new PointerType( Type::Qualifiers(), new VoidType( typeInst->get_qualifiers() ) );
-      delete typeInst;
-      return ret;
+    Expression * ScrubTyVars::mutate( SizeofExpr *szeof ) {
+        // sizeof( T ) => T parameter, which is the size of T
+        if ( TypeInstType *typeInst = dynamic_cast< TypeInstType * >( szeof->get_type() ) ) {
+            Expression *expr = new NameExpr( typeInst->get_name() );
+            return expr;
+        } else {
+            return Mutator::mutate( szeof );
+        }
     }
-      
-    case TypeDecl::Ftype:
-      delete typeInst;
-      return new PointerType( Type::Qualifiers(), new FunctionType( Type::Qualifiers(), true ) );
+
+    Type * ScrubTyVars::mutate( PointerType *pointer ) {
+        if ( TypeInstType *typeInst = dynamic_cast< TypeInstType * >( pointer->get_base() ) ) {
+            if ( doAll || tyVars.find( typeInst->get_name() ) != tyVars.end() ) {
+                Type *ret = mutate( typeInst );
+                ret->get_qualifiers() += pointer->get_qualifiers();
+                pointer->set_base( 0 );
+                delete pointer;
+                return ret;
+            }
+        }
+        return Mutator::mutate( pointer );
     }
-  }
-  return typeInst;
-}
-
-Type* 
-ScrubTyVars::mutate( PointerType *pointer )
-{
-  if( TypeInstType *typeInst = dynamic_cast< TypeInstType * >( pointer->get_base() ) ) {
-    if( doAll || tyVars.find( typeInst->get_name() ) != tyVars.end() ) {
-      Type *ret = mutate( typeInst );
-///       std::cout << "pointer is ";
-///       pointer->print( std::cout );
-///       std::cout << std::endl << "ret is ";
-///       ret->print( std::cout );
-///       std::cout << std::endl;
-      ret->get_qualifiers() += pointer->get_qualifiers();
-      pointer->set_base( 0 );
-      delete pointer;
-      return ret;
-    }
-  }
-  return Mutator::mutate( pointer );
-}
-
 } // namespace GenPoly

translator/GenPoly/ScrubTyVars.h

@@ -1 @@
-/*
- * This file is part of the Cforall project
- *
- * $Id: ScrubTyVars.h,v 1.4 2005/08/29 20:14:13 rcbilson Exp $
- *
- */
-
 #ifndef GENPOLY_SCRUBTYVARS_H
 #define GENPOLY_SCRUBTYVARS_H
@@ -15 +8 @@
 
 namespace GenPoly {
+    class ScrubTyVars : public Mutator {
+      public:
+        ScrubTyVars( bool doAll, const TyVarMap &tyVars ): doAll( doAll ), tyVars( tyVars ) {}
+  
+        template< typename SynTreeClass >
+        static SynTreeClass *scrub( SynTreeClass *target, const TyVarMap &tyVars );
+        template< typename SynTreeClass >
+        static SynTreeClass *scrub( SynTreeClass *target );
+  
+        virtual Type* mutate( TypeInstType *typeInst );
+        Expression* mutate( SizeofExpr *szeof );
+        virtual Type* mutate( PointerType *pointer );
+      private:
+        bool doAll;
+        const TyVarMap &tyVars;
+    };
 
-class ScrubTyVars : public Mutator
-{
-public:
-  ScrubTyVars( bool doAll, const TyVarMap &tyVars ): doAll( doAll ), tyVars( tyVars ) {}
-  
-  template< typename SynTreeClass >
-  static SynTreeClass *scrub( SynTreeClass *target, const TyVarMap &tyVars );
-  template< typename SynTreeClass >
-  static SynTreeClass *scrub( SynTreeClass *target );
-  
-  virtual Type* mutate( TypeInstType *typeInst );
-  virtual Type* mutate( PointerType *pointer );
+    /* static class method */
+    template< typename SynTreeClass >
+    SynTreeClass * ScrubTyVars::scrub( SynTreeClass *target, const TyVarMap &tyVars ) {
+        ScrubTyVars scrubber( false, tyVars );
+        return static_cast< SynTreeClass * >( target->acceptMutator( scrubber ) );
+    }
 
-private:
-  bool doAll;
-  const TyVarMap &tyVars;
-};
-
-/* static class method */
-template< typename SynTreeClass >
-SynTreeClass *
-ScrubTyVars::scrub( SynTreeClass *target, const TyVarMap &tyVars )
-{
-  ScrubTyVars scrubber( false, tyVars );
-  return static_cast< SynTreeClass* >( target->acceptMutator( scrubber ) );
-}
-
-/* static class method */
-template< typename SynTreeClass >
-SynTreeClass *
-ScrubTyVars::scrub( SynTreeClass *target )
-{
-  TyVarMap tyVars;
-  ScrubTyVars scrubber( true, tyVars );
-  return static_cast< SynTreeClass* >( target->acceptMutator( scrubber ) );
-}
-
+    /* static class method */
+    template< typename SynTreeClass >
+    SynTreeClass * ScrubTyVars::scrub( SynTreeClass *target ) {
+        TyVarMap tyVars;
+        ScrubTyVars scrubber( true, tyVars );
+        return static_cast< SynTreeClass* >( target->acceptMutator( scrubber ) );
+    }
 } // namespace GenPoly
 
-#endif /* #ifndef GENPOLY_SCRUBTYVARS_H */
+#endif // GENPOLY_SCRUBTYVARS_H

translator/InitTweak/InitModel.h

@@ -12 +12 @@
 
 namespace InitTweak {
+    class InitModelBuilder : public AssociationBuilder, public Visitor {
+      public:
+        InitModelBuilder( Declaration * );
+        ~InitModelBuilder();
 
-  class InitModelBuilder : public AssociationBuilder, public Visitor {
-  public:
-    InitModelBuilder( Declaration * );
-    ~InitModelBuilder();
+        virtual Association *grab_assoc() { taken = true; return building; }
+        virtual Association *get_assoc() { return building; }
+        void set_assoc( Association *newAssoc ) { building = newAssoc; }
 
-    virtual Association *grab_assoc() { taken = true; return building; }
-    virtual Association *get_assoc() { return building; }
-    void set_assoc( Association *newAssoc ) { building = newAssoc; }
+        void init();
+        static int interpretDimension( Expression *exp ) {
+            ConstantFolder folder( exp );
+            try {
+                return folder.get_constant();
+            } catch (...) {
+                throw SemanticError("Invalid array dimension");
+            }
+        }
 
-    void init();
-    static int interpretDimension( Expression *exp ) {
-      ConstantFolder folder( exp );
-      try {
-        return folder.get_constant();
-      } catch (...) {
-        throw SemanticError("Invalid array dimension");
-      }
-    }
+        // types
+        virtual void visit( ArrayType * );
+        virtual void visit( StructInstType * );
+        virtual void visit( UnionInstType * );
+        virtual void visit( EnumInstType * );
+        virtual void visit( ContextInstType * ) { throw 0; }
+        virtual void visit( TypeInstType * )    { throw 0; }
+        // virtual void visit( TupleType *tupleType );
+        // declarations
+        virtual void visit( StructDecl *);
+        virtual void visit( UnionDecl *);
+        virtual void visit( EnumDecl *);
+      private:
+        class ConstantFolder : public Visitor {
+          public:
+            ConstantFolder( Expression *_expr = 0 ): expr(_expr) {}
+            int get_constant() throw() { expr->accept( *this ); return value; }
+            void set_constant( Expression *newExp ) { expr = newExp; }
+            // Visitor interface
+            void visit( Expression * ) { throw 0; }
+            void visit( NameExpr * ) { throw 0; }
+            void visit( CastExpr * ) { throw 0; }
+            void visit( UntypedMemberExpr * ) { throw 0; }
+            void visit( VariableExpr * ) { throw 0; }
+            void visit( ConstantExpr * );
+            void visit( SizeofExpr * ) { throw 0; }
+            void visit( AttrExpr * ) { throw 0; }
+            void visit( LogicalExpr * ) { throw 0; }
+            void visit( ConditionalExpr * ) { throw 0; }
+            void visit( CommaExpr * ) { throw 0; }
+          private:
+            Expression *expr;
+            int value;
+        };
 
-    // types
-    virtual void visit( ArrayType * );
-    virtual void visit( StructInstType * );
-    virtual void visit( UnionInstType * );
-    virtual void visit( EnumInstType * );
-    virtual void visit( ContextInstType * ) { throw 0; }
-    virtual void visit( TypeInstType * )    { throw 0; }
-    // virtual void visit( TupleType *tupleType );
-    // declarations
-    virtual void visit( StructDecl *);
-    virtual void visit( UnionDecl *);
-    virtual void visit( EnumDecl *);
-
-  private:
-    class ConstantFolder : public Visitor {
-    public:
-      ConstantFolder( Expression *_expr = 0 ): expr(_expr) {}
-      int get_constant() throw() { expr->accept( *this ); return value; }
-      void set_constant( Expression *newExp ) { expr = newExp; }
-      // Visitor interface
-      void visit( Expression * ) { throw 0; }
-      void visit( NameExpr * ) { throw 0; }
-      void visit( CastExpr * ) { throw 0; }
-      void visit( UntypedMemberExpr * ) { throw 0; }
-      void visit( VariableExpr * ) { throw 0; }
-      void visit( ConstantExpr * );
-      void visit( SizeofExpr * ) { throw 0; }
-      void visit( AttrExpr * ) { throw 0; }
-      void visit( LogicalExpr * ) { throw 0; }
-      void visit( ConditionalExpr * ) { throw 0; }
-      void visit( CommaExpr * ) { throw 0; }
-    private:
-      Expression *expr;
-      int value;
+        bool taken;
+        Declaration *decl;  // ?
+        Association *building;
     };
 
-    bool taken;
-    Declaration *decl;  // ?
-    Association *building;
-  };
+    class InitModelFiller : public AssociationFiller, public Visitor {
+      public:
+        InitModelFiller( Association *, Initializer *, bool _topLevel = false );
+        ~InitModelFiller() { /* pointers in here are not owned by object (never created by object either) */ }
+        virtual Association *get_assoc() { return model; }
+        virtual void set_assoc( Association *newAssoc ) { model = newAssoc; }
 
-  class InitModelFiller : public AssociationFiller, public Visitor {
-  public:
-    InitModelFiller( Association *, Initializer *, bool _topLevel = false );
-    ~InitModelFiller() { /* pointers in here are not owned by object (never created by object either) */ }
-    virtual Association *get_assoc() { return model; }
-    virtual void set_assoc( Association *newAssoc ) { model = newAssoc; }
+        void init();
+        // Visitor interface
+        virtual void visit( SingleInit *singleInit );
+        virtual void visit( ListInit *listInit );
+      private:
+        Association *model;
+        Initializer *orgInit;
+        bool topLevel;
+        long int next;
+    };
 
-    void init();
-    // Visitor interface
-    virtual void visit( MemberInit *memberInit ) { throw 0; }
-    virtual void visit( ElementInit *elementInit ) { throw 0; }
-    virtual void visit( SingleInit *singleInit );
-    virtual void visit( ListInit *listInit );
+    class InitUnspooler : public AssociationVisitor {
+      public:
+        InitUnspooler() : init(0), taken( false ) {}
+        virtual ~InitUnspooler() { if (!taken && (init != 0)) { delete init; init = 0; } }
+        Initializer *get_initializer() { return init; }
+        Initializer *grab_initializer() { taken = true; return init; }
 
-  private:
-    Association *model;
-    Initializer *orgInit;
-    bool topLevel;
-    long int next;
-  };
-
-  class InitUnspooler : public AssociationVisitor {
-  public:
-    InitUnspooler() : init(0), taken( false ) {}
-    virtual ~InitUnspooler() { if (!taken && (init != 0)) { delete init; init = 0; } }
-    Initializer *get_initializer() { return init; }
-    Initializer *grab_initializer() { taken = true; return init; }
-
-    virtual void visit( SingleName * );
-    virtual void visit( PointAssociation * );
-    virtual void visit( RangeAssociation * ) { std::cerr << "InitUnspooler - In a range assoc" << std::endl; return; }
-
-  private:
-    Initializer *init;
-    bool taken;
-  };
+        virtual void visit( SingleName * );
+        virtual void visit( PointAssociation * );
+        virtual void visit( RangeAssociation * ) { std::cerr << "InitUnspooler - In a range assoc" << std::endl; return; }
+      private:
+        Initializer *init;
+        bool taken;
+    };
 
 } // namespace InitTweak
 
-#endif // #define _INITTWEAK_MODEL_H_
+#endif // _INITTWEAK_MODEL_H_
 
 /*

translator/Parser/DeclarationNode.cc

@@ -5 +5 @@
 #include <cassert>
 
-#include "ParseNode.h"
 #include "TypeData.h"
-#include "utility.h"
-#include "SynTree/Declaration.h"
 #include "SynTree/Expression.h"
-#include "SynTree/Initializer.h"
-#include "SemanticError.h"
-#include "UniqueName.h"
-#include "LinkageSpec.h"
+
 
 using namespace std;
 
-/* these must remain in the same order as the corresponding DeclarationNode enumerations */
-const char *DeclarationNode::qualifierName[] = { "const", "restrict", "volatile", "lvalue" };
+// These must remain in the same order as the corresponding DeclarationNode enumerations.
+const char *DeclarationNode::qualifierName[] = { "const", "restrict", "volatile", "lvalue", "_Atomic" };
 const char *DeclarationNode::basicTypeName[] = { "char", "int", "float", "double", "void", "_Bool", "_Complex", "_Imaginary" };
 const char *DeclarationNode::modifierName[] = { "signed", "unsigned", "short", "long" };
@@ -67 +61 @@
     os << string(indent, ' ' );
     if ( name == "" ) {
-///     os << "An unnamed ";
+        os << "unnamed: ";
     } else {
-        os << name << ": a ";
+        os << name << ": ";
     }
 
@@ -862 +856 @@
               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;
@@ -884 +875 @@
       default:
         return type->build();
-    }
+    } // switch
 }
 

translator/Parser/ExpressionNode.cc

@@ -16 +16 @@
 ExpressionNode::ExpressionNode() : ParseNode(), argName( 0 ) {}
 
-ExpressionNode::ExpressionNode(string *name_) : ParseNode( *name_ ), argName( 0 ) {
+ExpressionNode::ExpressionNode( string *name_) : ParseNode( *name_ ), argName( 0 ) {
     delete name_;
 }
@@ -25 +25 @@
     } else {
         argName = 0;
-    }
+    } // if
 }
 
 ExpressionNode * ExpressionNode::set_asArgName( std::string *aName ) {
-    argName = new VarRefNode(aName);
+    argName = new VarRefNode( aName );
     return this;
 }
@@ -40 +40 @@
 void ExpressionNode::printDesignation( std::ostream &os, int indent ) const {
     if ( argName ) {
-        os << string(' ', indent) << "(designated by:  ";
-        argName->printOneLine(os, indent );
+        os << string(' ', indent ) << "(designated by:  ";
+        argName->printOneLine( os, indent );
         os << ")" << std::endl;
-    }
+    } // if
 }
 
@@ -52 +52 @@
 }
 
-void NullExprNode::print(std::ostream & os, int indent) const {
-    printDesignation(os);
+void NullExprNode::print( std::ostream & os, int indent ) const {
+    printDesignation( os );
     os << "null expression";
 }
 
-void NullExprNode::printOneLine(std::ostream & os, int indent) const {
-    printDesignation(os);
+void NullExprNode::printOneLine( std::ostream & os, int indent ) const {
+    printDesignation( os );
     os << "null";
 }
@@ -66 +66 @@
 }
 
-CommaExprNode *ExpressionNode::add_to_list(ExpressionNode *exp){
-    return new CommaExprNode(this, exp );
+CommaExprNode *ExpressionNode::add_to_list( ExpressionNode *exp ){
+    return new CommaExprNode( this, exp );
 }
 
 //  enum ConstantNode::Type =  { Integer, Float, Character, String, Range }
 
-ConstantNode::ConstantNode(void) : ExpressionNode(), sign(true), longs(0), size(0) {}
-
-ConstantNode::ConstantNode(string *name_) : ExpressionNode(name_), sign(true), longs(0), size(0) {}
-
-ConstantNode::ConstantNode(Type t, string *inVal) : type(t), sign(true), longs(0), size(0) {
+ConstantNode::ConstantNode( void ) : ExpressionNode(), sign( true ), longs(0), size(0) {}
+
+ConstantNode::ConstantNode( string *name_) : ExpressionNode( name_), sign( true ), longs(0), size(0) {}
+
+ConstantNode::ConstantNode( Type t, string *inVal ) : type( t ), sign( true ), longs(0), size(0) {
     if ( inVal ) {
         value = *inVal;
@@ -82 +82 @@
     } else {
         value = "";
-    }
-
-    classify(value);
+    } // if
+
+    classify( value );
 }
 
@@ -96 +96 @@
 }
 
-void ConstantNode::classify(std::string &str){
-    switch (type){
+void ConstantNode::classify( std::string &str ){
+    switch ( type ){
       case Integer:
       case Float:
@@ -105 +105 @@
             int i = str.length() - 1;
 
-            while ( i >= 0 && !isxdigit(c = str.at(i--)) )
+            while ( i >= 0 && !isxdigit( c = str.at( i--)) )
                 sfx += c;
 
@@ -111 +111 @@
 
             // get rid of underscores
-            value.erase(remove(value.begin(), value.end(), '_'), value.end());
-
-            std::transform(sfx.begin(), sfx.end(), sfx.begin(), tolower_hack);
+            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 ){
+            } else if ( sfx.find("l") != string::npos ){
                 longs = 1;
-            }
-
-            assert((longs >= 0) && (longs <= 2));
+            } // if
+
+            assert(( longs >= 0) && ( longs <= 2));
 
             if ( sfx.find("u") != string::npos )
@@ -131 +131 @@
         {
             // remove underscores from hex and oct escapes
-            if (str.substr(1,2) == "\\x")
-                value.erase(remove(value.begin(), value.end(), '_'), value.end());
+            if ( str.substr(1,2) == "\\x")
+                value.erase( remove( value.begin(), value.end(), '_'), value.end());
 
             break;
@@ -142 +142 @@
 }
 
-ConstantNode::Type ConstantNode::get_type(void) const {
+ConstantNode::Type ConstantNode::get_type( void ) const {
     return type;
 }
@@ -148 +148 @@
 ConstantNode *ConstantNode::append( std::string *newValue ) {
     if ( newValue ) {
-        if (type == String){
+        if ( type == String ){
             std::string temp = *newValue;
             value.resize( value.size() - 1 );
@@ -156 +156 @@
 
         delete newValue;
-    }
+    } // if
     return this;
 }
 
-void ConstantNode::printOneLine(std::ostream &os, int indent ) const {
-    os << string(indent, ' ');
-    printDesignation(os);
+void ConstantNode::printOneLine( std::ostream &os, int indent ) const {
+    os << string( indent, ' ');
+    printDesignation( os );
 
     switch ( type ) {
@@ -185 +185 @@
 }
 
-void ConstantNode::print(std::ostream &os, int indent ) const {
+void ConstantNode::print( std::ostream &os, int indent ) const {
     printOneLine( os, indent );
     os << endl;
@@ -194 +194 @@
     BasicType *bt;
 
-    switch (get_type()){
+    switch ( get_type()){
       case Integer:
         /* Cfr. standard 6.4.4.1 */
-        //bt.set_kind(BasicType::SignedInt);
-        bt = new BasicType(q, BasicType::SignedInt);
+        //bt.set_kind( BasicType::SignedInt );
+        bt = new BasicType( q, BasicType::SignedInt );
         break;
       case Float:
-        bt = new BasicType(q, BasicType::Float);
+        bt = new BasicType( q, BasicType::Float );
         break;
       case Character:
-        bt = new BasicType(q, BasicType::Char);
+        bt = new BasicType( q, BasicType::Char );
         break;
       case String:
@@ -210 +210 @@
         ArrayType *at;
         std::string value = get_value();
-        at = new ArrayType(q, new BasicType(q, BasicType::Char),
-                           new ConstantExpr( Constant( new BasicType(q, BasicType::SignedInt),
+        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( at, value ), maybeBuild< Expression >( get_argName() ) );
     }
-    return new ConstantExpr(  Constant(bt, get_value()),  maybeBuild< Expression >( get_argName() ) );
-}
-
-VarRefNode::VarRefNode() : isLabel(false) {}
-
-VarRefNode::VarRefNode(string *name_, bool labelp) : ExpressionNode(name_), isLabel(labelp) {}
+    return new ConstantExpr(  Constant( bt, get_value()),  maybeBuild< Expression >( get_argName() ) );
+}
+
+VarRefNode::VarRefNode() : isLabel( false ) {}
+
+VarRefNode::VarRefNode( string *name_, bool labelp ) : ExpressionNode( name_), isLabel( labelp ) {}
 
 VarRefNode::VarRefNode( const VarRefNode &other ) : ExpressionNode( other ), isLabel( other.isLabel ) {
@@ -230 +230 @@
 }
 
-void VarRefNode::printOneLine(std::ostream &os, int indent ) const {
-    printDesignation(os);
+void VarRefNode::printOneLine( std::ostream &os, int indent ) const {
+    printDesignation( os );
     os << get_name() << ' ';
 }
 
-void VarRefNode::print(std::ostream &os, int indent ) const {
-    printDesignation(os);
-    os << '\r' << string(indent, ' ') << "Referencing: ";
+void VarRefNode::print( std::ostream &os, int indent ) const {
+    printDesignation( os );
+    os << '\r' << string( indent, ' ') << "Referencing: ";
     os << "Variable: " << get_name();
     os << endl;
 }
 
-OperatorNode::OperatorNode(Type t) : type(t) {}
+OperatorNode::OperatorNode( Type t ) : type( t ) {}
 
 OperatorNode::OperatorNode( const OperatorNode &other ) : ExpressionNode( other ), type( other.type ) {
@@ -249 +249 @@
 OperatorNode::~OperatorNode() {}
 
-OperatorNode::Type OperatorNode::get_type(void) const{
+OperatorNode::Type OperatorNode::get_type( void ) const{
     return type;
 }
 
 void OperatorNode::printOneLine( std::ostream &os, int indent ) const {
-    printDesignation(os);
+    printDesignation( os );
     os << OpName[ type ] << ' ';
 }
 
 void OperatorNode::print( std::ostream &os, int indent ) const{
-    printDesignation(os);
-    os << '\r' << string(indent, ' ') << "Operator: " << OpName[type] << endl;
+    printDesignation( os );
+    os << '\r' << string( indent, ' ') << "Operator: " << OpName[type] << endl;
     return;
 }
 
-std::string OperatorNode::get_typename(void) const{
-    return string(OpName[ type ]);
+std::string OperatorNode::get_typename( void ) const{
+    return string( OpName[ type ]);
 }
 
@@ -282 +282 @@
 };
 
-CompositeExprNode::CompositeExprNode(void) : ExpressionNode(), function( 0 ), arguments( 0 ) {
-}
-
-CompositeExprNode::CompositeExprNode(string *name_) : ExpressionNode(name_), function( 0 ), arguments( 0 ) {
-}
-
-CompositeExprNode::CompositeExprNode(ExpressionNode *f, ExpressionNode *args):
-    function(f), arguments(args) {
-}
-
-CompositeExprNode::CompositeExprNode(ExpressionNode *f, ExpressionNode *arg1, ExpressionNode *arg2):
-    function(f), arguments(arg1) {
-    arguments->set_link(arg2);
+CompositeExprNode::CompositeExprNode( void ) : ExpressionNode(), function( 0 ), arguments( 0 ) {
+}
+
+CompositeExprNode::CompositeExprNode( string *name_) : ExpressionNode( name_), function( 0 ), arguments( 0 ) {
+}
+
+CompositeExprNode::CompositeExprNode( ExpressionNode *f, ExpressionNode *args ):
+    function( f ), arguments( args ) {
+}
+
+CompositeExprNode::CompositeExprNode( ExpressionNode *f, ExpressionNode *arg1, ExpressionNode *arg2):
+    function( f ), arguments( arg1) {
+    arguments->set_link( arg2);
 }
 
@@ -303 +303 @@
             arguments->set_link( cur->clone() );
         } else {
-            arguments = (ExpressionNode*)cur->clone();
-        }
+            arguments = ( ExpressionNode*)cur->clone();
+        } // if
         cur = cur->get_link();
     }
@@ -333 +333 @@
     std::list<Expression *> args;
 
-    buildList(get_args(), args);
-
-    if ( ! ( op = dynamic_cast<OperatorNode *>(function)) ) {
+    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() ));
+        return new UntypedExpr( function->build(), args, maybeBuild< Expression >( get_argName() ));
     } else {
-        switch (op->get_type()){
+        switch ( op->get_type()){
           case OperatorNode::Incr:
           case OperatorNode::Decr:
@@ -412 +412 @@
           case OperatorNode::Cast:
             {
-                TypeValueNode * arg = dynamic_cast<TypeValueNode *>(get_args());
+                TypeValueNode * arg = dynamic_cast<TypeValueNode *>( get_args());
                 assert( arg );
 
                 DeclarationNode *decl_node = arg->get_decl();
-                ExpressionNode *expr_node = dynamic_cast<ExpressionNode *>(arg->get_link());
+                ExpressionNode *expr_node = dynamic_cast<ExpressionNode *>( arg->get_link());
 
                 Type *targetType = decl_node->buildType();
@@ -423 +423 @@
                     return new CastExpr( expr_node->build(), maybeBuild< Expression >( get_argName() ) );
                 } else {
-                    return new CastExpr(expr_node->build(),targetType, maybeBuild< Expression >( get_argName() ) );
-                }
+                    return new CastExpr( expr_node->build(),targetType, maybeBuild< Expression >( get_argName() ) );
+                } // if
             }
           case OperatorNode::FieldSel:
@@ -430 +430 @@
                 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;
-                    }
+                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());
+                   UntypedMemberExpr *ret = new UntypedMemberExpr( memberTup->get_name(), args.front());
                    delete member;
                    return ret;
                    } */
-                else
+                } else
                     assert( false );
             }
@@ -452 +450 @@
                 assert( args.size() == 2 );
 
-                NameExpr *member = dynamic_cast<NameExpr *>(args.back());  // modify for Tuples   xxx
+                NameExpr *member = dynamic_cast<NameExpr *>( args.back());  // modify for Tuples   xxx
                 assert( member != 0 );
 
@@ -458 +456 @@
                 deref->get_args().push_back( args.front() );
 
-                UntypedMemberExpr *ret = new UntypedMemberExpr(member->get_name(), deref);
+                UntypedMemberExpr *ret = new UntypedMemberExpr( member->get_name(), deref );
                 delete member;
                 return ret;
@@ -465 +463 @@
           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());
+///     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());
-                }
+                    return new SizeofExpr( args.front());
+                } // if
             }
           case OperatorNode::Attr:
             {
-                VarRefNode *var = dynamic_cast<VarRefNode *>(get_args());
+                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());
+                    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());
-                }
+                    return new AttrExpr( var->build(), args.back());
+                } // if
             }
           case OperatorNode::CompLit:
@@ -490 +488 @@
           case OperatorNode::Or:
           case OperatorNode::And:
-            assert(args.size() == 2);
-            return new LogicalExpr( notZeroExpr( args.front() ), notZeroExpr( args.back() ), (op->get_type() == 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);
+                assert( args.size() == 3);
                 std::list< Expression* >::const_iterator i = args.begin();
                 Expression *arg1 = notZeroExpr( *i++ );
@@ -505 +503 @@
           case OperatorNode::Comma:
             {
-                assert(args.size() == 2);
+                assert( args.size() == 2);
                 std::list< Expression* >::const_iterator i = args.begin();
                 Expression *ret = *i++;
@@ -527 +525 @@
 }
 
-void CompositeExprNode::printOneLine(std::ostream &os, int indent) const {
-    printDesignation(os);
+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() ) ) {
+    for ( ExpressionNode *cur = arguments; cur != 0; cur = dynamic_cast< ExpressionNode* >( cur->get_link() ) ) {
         cur->printOneLine( os, indent );
     }
@@ -537 +535 @@
 }
 
-void CompositeExprNode::print(std::ostream &os, int indent) const {
-    printDesignation(os);
-    os << '\r' << string(indent, ' ') << "Application of: " << endl;
+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, ' ') ;
+    os << '\r' << string( indent, ' ') ;
     if ( arguments ) {
         os << "... on arguments: " << endl;
-        arguments->printList(os, indent + ParseNode::indent_by);
+        arguments->printList( os, indent + ParseNode::indent_by );
     } else
         os << "... on no arguments: " << endl;
 }
 
-void CompositeExprNode::set_function(ExpressionNode *f){
+void CompositeExprNode::set_function( ExpressionNode *f ){
     function = f;
 }
 
-void CompositeExprNode::set_args(ExpressionNode *args){
+void CompositeExprNode::set_args( ExpressionNode *args ){
     arguments = args;
 }
 
-ExpressionNode *CompositeExprNode::get_function(void) const {
+ExpressionNode *CompositeExprNode::get_function( void ) const {
     return function;
 }
 
-ExpressionNode *CompositeExprNode::get_args(void) const {
+ExpressionNode *CompositeExprNode::get_args( void ) const {
     return arguments;
 }
 
-void CompositeExprNode::add_arg(ExpressionNode *arg){
-    if (arguments)
-        arguments->set_link(arg);
+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);
+        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;
@@ -590 +588 @@
 }
 
-ValofExprNode::ValofExprNode(StatementNode *s): body(s) {}
+ValofExprNode::ValofExprNode( StatementNode *s ): body( s ) {}
 
 ValofExprNode::ValofExprNode( const ValofExprNode &other ) : ExpressionNode( other ), body( maybeClone( body ) ) {
@@ -600 +598 @@
 
 void ValofExprNode::print( std::ostream &os, int indent ) const {
-    printDesignation(os);
-    os << string(indent, ' ') << "Valof Expression:" << std::endl;
-    get_body()->print(os, indent + 4);
+    printDesignation( os );
+    os << string( indent, ' ') << "Valof Expression:" << std::endl;
+    get_body()->print( os, indent + 4);
 }
 
@@ -613 +611 @@
 }
 
-ForCtlExprNode::ForCtlExprNode(ParseNode *init_, ExpressionNode *cond, ExpressionNode *incr) throw (SemanticError) : condition(cond), change(incr) {
+ForCtlExprNode::ForCtlExprNode( ParseNode *init_, ExpressionNode *cond, ExpressionNode *incr ) throw ( SemanticError ) : condition( cond ), change( incr ) {
     if ( init_ == 0 )
         init = 0;
@@ -620 +618 @@
         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);
+        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");
@@ -646 +644 @@
 
 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)
-        condition->print(os, indent + 4);
-    os << "\n\r" << string(indent + 2,' ') << "increment: ";
-    if (change != 0)
-        change->print(os, indent + 4);
+    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)
+        condition->print( os, indent + 4);
+    os << "\n\r" << string( indent + 2,' ') << "increment: ";
+    if ( change != 0)
+        change->print( os, indent + 4);
 }
 
@@ -664 +662 @@
 }
 
-TypeValueNode::TypeValueNode(DeclarationNode *decl)
+TypeValueNode::TypeValueNode( DeclarationNode *decl )
     : decl( decl ) {
 }
@@ -676 +674 @@
 }
 
-void TypeValueNode::print(std::ostream &os, int indent) const {
+void TypeValueNode::print( std::ostream &os, int indent ) const {
     os << std::string( indent, ' ' ) << "Type:";
-    get_decl()->print(os, indent + 2);
-}
-
-void TypeValueNode::printOneLine(std::ostream &os, int indent) const {
+    get_decl()->print( os, indent + 2);
+}
+
+void TypeValueNode::printOneLine( std::ostream &os, int indent ) const {
     os << "Type:";
-    get_decl()->print(os, indent + 2);
+    get_decl()->print( os, indent + 2);
 }
 
@@ -690 +688 @@
         {
             OperatorNode *op;
-            if ( (op = dynamic_cast< OperatorNode * >( composite->get_function() )) && (op->get_type() == OperatorNode::Comma) )
+            if ( ( op = dynamic_cast< OperatorNode * >( composite->get_function() )) && ( op->get_type() == OperatorNode::Comma ) )
                 {
                     if ( ExpressionNode *next = dynamic_cast< ExpressionNode * >( list->get_link() ) )
@@ -707 +705 @@
     if ( CompositeExprNode *composite = dynamic_cast< CompositeExprNode * >( tuple ) ) {
         OperatorNode *op = 0;
-        if ( (op = dynamic_cast< OperatorNode * >( composite->get_function() )) && (op->get_type() == OperatorNode::TupleC) )
+        if ( ( op = dynamic_cast< OperatorNode * >( composite->get_function() )) && ( op->get_type() == OperatorNode::TupleC ) )
             return composite->get_args();
     }

translator/Parser/InitializerNode.cc

@@ +1 @@
+#include <cassert>
+#include <iostream>
+using namespace std;
+
 #include "ParseNode.h"
 #include "SynTree/Expression.h"
 #include "SynTree/Initializer.h"
-#include "utility.h"
-#include "SemanticError.h"
-// #include <cstdlib> // for strtol
-#include <cassert>
-
-#include <iostream>
-using namespace std;
 
 InitializerNode::InitializerNode( ExpressionNode *_expr, bool aggrp, ExpressionNode *des )

translator/Parser/ParseNode.cc

@@ -73 +73 @@
 }
 
-ParseNode *mkList(ParseNode &pn){
+ParseNode *mkList( ParseNode &pn ) {
     /* it just relies on `operator,' to take care of the "arguments" and provides
        a nice interface to an awful-looking address-of, rendering, for example
        (StatementNode *)(&(*$5 + *$7)) into (StatementNode *)mkList(($5, $7))
-       (although "nice"  is probably not the word)
+       (although "nice" is probably not the word)
     */
     return &pn;

translator/Parser/ParseNode.h

@@ -2 +2 @@
 #define PARSENODE_H
 
-#include <iostream>
 #include <string>
 #include <list>
@@ -8 +7 @@
 
 #include "utility.h"
-#include "SynTree/SynTree.h"
 #include "SynTree/Declaration.h"
-#include "SemanticError.h"
 #include "UniqueName.h"
 
@@ -23 +20 @@
 // Builder
 class ParseNode {
-public:
-  ParseNode(void);
-  ParseNode (std::string);
-  virtual ~ParseNode(void);
-
-  ParseNode *set_name (std::string) ;
-  ParseNode *set_name (std::string *) ;
-
-  std::string get_name(void);
-
-  ParseNode *get_link(void) const;
-  ParseNode *get_last(void);
-  ParseNode *set_link(ParseNode *);
-  void set_next( ParseNode *newlink ) { next = newlink; }
-
-  virtual ParseNode *clone() const { return 0; };
-
-  const std::string get_name(void) const;
-  virtual void print( std::ostream &, int indent = 0 ) const;
-  virtual void printList( std::ostream &, int indent = 0 ) const;
-
-  ParseNode &operator,(ParseNode &);
-
-protected:
-  std::string name;
-  ParseNode *next;
-  static int indent_by;
-};
-
-ParseNode *mkList(ParseNode &);
+  public:
+    ParseNode( void );
+    ParseNode ( std::string );
+    virtual ~ParseNode( void );
+
+    ParseNode *set_name ( std::string ) ;
+    ParseNode *set_name ( std::string * ) ;
+
+    std::string get_name( void );
+
+    ParseNode *get_link( void ) const;
+    ParseNode *get_last( void );
+    ParseNode *set_link( ParseNode * );
+    void set_next( ParseNode *newlink ) { next = newlink; }
+
+    virtual ParseNode *clone() const { return 0; };
+
+    const std::string get_name( void ) const;
+    virtual void print( std::ostream &, int indent = 0 ) const;
+    virtual void printList( std::ostream &, int indent = 0 ) const;
+
+    ParseNode &operator,( ParseNode &);
+  protected:
+    std::string name;
+    ParseNode *next;
+    static int indent_by;
+};
+
+ParseNode *mkList( ParseNode & );
 
 class ExpressionNode : public ParseNode {
-public:
-  ExpressionNode();
-  ExpressionNode(std::string *);
-  ExpressionNode( const ExpressionNode &other );
-  virtual ~ExpressionNode() { /* can't delete asArgName because it might be referenced elsewhere */ };
-
-  virtual ExpressionNode *clone() const = 0;
-
-  virtual CommaExprNode *add_to_list(ExpressionNode *);
-
-  ExpressionNode *get_argName() const { return argName; }
-  ExpressionNode *set_asArgName( std::string *aName );
-  ExpressionNode *set_asArgName( ExpressionNode *aDesignator );
-
-  virtual void print(std::ostream &, int indent = 0) const = 0;
-  virtual void printOneLine(std::ostream &, int indent = 0) const = 0;
-
-  virtual Expression *build() const = 0;
-protected:
-  void printDesignation (std::ostream &, int indent = 0) const;
-
-private:
-  ExpressionNode *argName;
-};
-
-// NullExprNode is used in tuples as a place-holder where a tuple component is omitted
-// e.g., [ 2, , 3 ]
-class NullExprNode : public ExpressionNode
-{
-public:
-  NullExprNode();
-
-  virtual NullExprNode *clone() const;
-
-  virtual void print(std::ostream &, int indent = 0) const;
-  virtual void printOneLine(std::ostream &, int indent = 0) const;
-
-  virtual Expression *build() const;
+  public:
+    ExpressionNode();
+    ExpressionNode( std::string * );
+    ExpressionNode( const ExpressionNode &other );
+    virtual ~ExpressionNode() { /* can't delete asArgName because it might be referenced elsewhere */ };
+
+    virtual ExpressionNode *clone() const = 0;
+
+    virtual CommaExprNode *add_to_list( ExpressionNode * );
+
+    ExpressionNode *get_argName() const { return argName; }
+    ExpressionNode *set_asArgName( std::string *aName );
+    ExpressionNode *set_asArgName( ExpressionNode *aDesignator );
+
+    virtual void print( std::ostream &, int indent = 0) const = 0;
+    virtual void printOneLine( std::ostream &, int indent = 0) const = 0;
+
+    virtual Expression *build() const = 0;
+  protected:
+    void printDesignation ( std::ostream &, int indent = 0) const;
+  private:
+    ExpressionNode *argName;
+};
+
+// NullExprNode is used in tuples as a place-holder where a tuple component is omitted e.g., [ 2, , 3 ]
+class NullExprNode : public ExpressionNode {
+  public:
+    NullExprNode();
+
+    virtual NullExprNode *clone() const;
+
+    virtual void print( std::ostream &, int indent = 0) const;
+    virtual void printOneLine( std::ostream &, int indent = 0) const;
+
+    virtual Expression *build() const;
 };
 
 class ConstantNode : public ExpressionNode {
-public:
-  enum Type {
-    Integer, Float, Character, String /* , Range, EnumConstant  */
-  };
-
-  ConstantNode(void);
-  ConstantNode(std::string *);
-  ConstantNode(Type, std::string *);
-  ConstantNode( const ConstantNode &other );
-
-  virtual ConstantNode *clone() const { return new ConstantNode( *this ); }
-
-  Type get_type(void) const ;
-  virtual void print(std::ostream &, int indent = 0) const;
-  virtual void printOneLine(std::ostream &, int indent = 0) const;
-
-  std::string get_value() const { return value; }
-  ConstantNode *append( std::string *newValue );
-
-  Expression *build() const;
-
-private:
-  void classify(std::string &);
-  Type type;
-  std::string value;
-  bool sign;
-  short base;
-  int longs, size;
+  public:
+    enum Type {
+        Integer, Float, Character, String /* , Range, EnumConstant  */
+    };
+
+    ConstantNode( void );
+    ConstantNode( std::string * );
+    ConstantNode( Type, std::string * );
+    ConstantNode( const ConstantNode &other );
+
+    virtual ConstantNode *clone() const { return new ConstantNode( *this ); }
+
+    Type get_type( void ) const ;
+    virtual void print( std::ostream &, int indent = 0) const;
+    virtual void printOneLine( std::ostream &, int indent = 0) const;
+
+    std::string get_value() const { return value; }
+    ConstantNode *append( std::string *newValue );
+
+    Expression *build() const;
+  private:
+    void classify( std::string &);
+    Type type;
+    std::string value;
+    bool sign;
+    short base;
+    int longs, size;
 };
 
 class VarRefNode : public ExpressionNode {
-public:
-  VarRefNode();
-  VarRefNode(std::string *, bool isLabel = false );
-  VarRefNode( const VarRefNode &other );
-
-  virtual Expression *build() const ;
-
-  virtual VarRefNode *clone() const { return new VarRefNode( *this ); }
-
-  virtual void print(std::ostream &, int indent = 0) const;
-  virtual void printOneLine(std::ostream &, int indent = 0) const;
-private:
-  bool isLabel;
-};
-
-class TypeValueNode : public ExpressionNode
-{
-public:
-  TypeValueNode(DeclarationNode *);
-  TypeValueNode( const TypeValueNode &other );
-
-  DeclarationNode *get_decl() const { return decl; }
-
-  virtual Expression *build() const ;
-
-  virtual TypeValueNode *clone() const { return new TypeValueNode( *this ); }
-
-  virtual void print(std::ostream &, int indent = 0) const;
-  virtual void printOneLine(std::ostream &, int indent = 0) const;
-private:
-  DeclarationNode *decl;
+  public:
+    VarRefNode();
+    VarRefNode( std::string *, bool isLabel = false );
+    VarRefNode( const VarRefNode &other );
+
+    virtual Expression *build() const ;
+
+    virtual VarRefNode *clone() const { return new VarRefNode( *this ); }
+
+    virtual void print( std::ostream &, int indent = 0) const;
+    virtual void printOneLine( std::ostream &, int indent = 0) const;
+  private:
+    bool isLabel;
+};
+
+class TypeValueNode : public ExpressionNode {
+  public:
+    TypeValueNode( DeclarationNode * );
+    TypeValueNode( const TypeValueNode &other );
+
+    DeclarationNode *get_decl() const { return decl; }
+
+    virtual Expression *build() const ;
+
+    virtual TypeValueNode *clone() const { return new TypeValueNode( *this ); }
+
+    virtual void print( std::ostream &, int indent = 0) const;
+    virtual void printOneLine( std::ostream &, int indent = 0) const;
+  private:
+    DeclarationNode *decl;
 };
 
 class OperatorNode : public ExpressionNode {
-public:
-  enum Type { TupleC, Comma, TupleFieldSel,
-              Cond, NCond, 
-              SizeOf, AlignOf, Attr, CompLit, Plus, Minus, Mul, Div, Mod, Or, And, 
+  public:
+    enum Type { TupleC, Comma, TupleFieldSel,
+                Cond, NCond, 
+                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,
-              UnPlus, UnMinus, AddressOf, PointTo, Neg, BitNeg, Incr, IncrPost, Decr, DecrPost, LabelAddress
-            };
-
-  OperatorNode(Type t);
-  OperatorNode( const OperatorNode &other );
-  virtual ~OperatorNode();
-
-  virtual OperatorNode *clone() const { return new OperatorNode( *this ); }
-
-  Type get_type(void) const;
-  std::string get_typename(void) const;
-
-  virtual void print(std::ostream &, int indent = 0) const;
-  virtual void printOneLine(std::ostream &, int indent = 0) const;
-
-  virtual Expression *build() const { return 0; }
+                UnPlus, UnMinus, AddressOf, PointTo, Neg, BitNeg, Incr, IncrPost, Decr, DecrPost, LabelAddress
+    };
+
+    OperatorNode( Type t );
+    OperatorNode( const OperatorNode &other );
+    virtual ~OperatorNode();
+
+    virtual OperatorNode *clone() const { return new OperatorNode( *this ); }
+
+    Type get_type( void ) const;
+    std::string get_typename( void ) const;
+
+    virtual void print( std::ostream &, int indent = 0) const;
+    virtual void printOneLine( std::ostream &, int indent = 0) const;
+
+    virtual Expression *build() const { return 0; }
+  private:
+    Type type;
+    static const char *OpName[];
+};
+
+
+class CompositeExprNode : public ExpressionNode {
+  public:
+    CompositeExprNode( void );
+    CompositeExprNode( std::string * );
+    CompositeExprNode( ExpressionNode *f, ExpressionNode *args = 0 );
+    CompositeExprNode( ExpressionNode *f, ExpressionNode *arg1, ExpressionNode *arg2 );
+    CompositeExprNode( const CompositeExprNode &other );
+    virtual ~CompositeExprNode();
+
+    virtual CompositeExprNode *clone() const { return new CompositeExprNode( *this ); }
+    virtual Expression *build() const;
+
+    virtual void print( std::ostream &, int indent = 0) const;
+    virtual void printOneLine( std::ostream &, int indent = 0) const;
+
+    void set_function( ExpressionNode * );
+    void set_args( ExpressionNode * );
+
+    void add_arg( ExpressionNode * );
+
+    ExpressionNode *get_function() const;
+    ExpressionNode *get_args() const;
+  private:
+    ExpressionNode *function;
+    ExpressionNode *arguments;
+};
+
+class CommaExprNode : public CompositeExprNode {
+  public:
+    CommaExprNode();
+    CommaExprNode( ExpressionNode * );
+    CommaExprNode( ExpressionNode *, ExpressionNode * );
+    CommaExprNode( const CommaExprNode &other );
+
+    virtual CommaExprNode *add_to_list( ExpressionNode * );
+    virtual CommaExprNode *clone() const { return new CommaExprNode( *this ); }
+};
+
+class ForCtlExprNode : public ExpressionNode {
+  public:
+    ForCtlExprNode( ParseNode *, ExpressionNode *, ExpressionNode * ) throw ( SemanticError );
+    ForCtlExprNode( const ForCtlExprNode &other );
+    ~ForCtlExprNode();
+
+    StatementNode *get_init() const { return init; }
+    ExpressionNode *get_condition() const { return condition; }
+    ExpressionNode *get_change() const { return change; }
+
+    virtual ForCtlExprNode *clone() const { return new ForCtlExprNode( *this ); }
+    virtual Expression *build() const;
+
+    virtual void print( std::ostream &, int indent = 0 ) const;
+    virtual void printOneLine( std::ostream &, int indent = 0 ) const;
+  private:
+    StatementNode *init;
+    ExpressionNode *condition;
+    ExpressionNode *change;
+};
+
+class ValofExprNode : public ExpressionNode {
+  public:
+    ValofExprNode();
+    ValofExprNode( StatementNode *s = 0 );
+    ValofExprNode( const ValofExprNode &other );
+    ~ValofExprNode();
   
-private:
-  Type type;
-  static const char *OpName[];
-};
-
-
-class CompositeExprNode : public ExpressionNode {
-public:
-  CompositeExprNode(void);
-  CompositeExprNode(std::string *);
-  CompositeExprNode(ExpressionNode *f, ExpressionNode *args = 0);
-  CompositeExprNode(ExpressionNode *f, ExpressionNode *arg1, ExpressionNode *arg2);
-  CompositeExprNode( const CompositeExprNode &other );
-  virtual ~CompositeExprNode();
-
-  virtual CompositeExprNode *clone() const { return new CompositeExprNode( *this ); }
-  virtual Expression *build() const;
-
-  virtual void print(std::ostream &, int indent = 0) const;
-  virtual void printOneLine(std::ostream &, int indent = 0) const;
-
-  void set_function(ExpressionNode *);
-  void set_args(ExpressionNode *);
-
-  void add_arg(ExpressionNode *);
-
-  ExpressionNode *get_function() const;
-  ExpressionNode *get_args() const;
-
-private:
-  ExpressionNode *function;
-  ExpressionNode *arguments;
-};
-
-class CommaExprNode : public CompositeExprNode {
-public:
-  CommaExprNode();
-  CommaExprNode(ExpressionNode *);
-  CommaExprNode(ExpressionNode *, ExpressionNode *);
-  CommaExprNode( const CommaExprNode &other );
-
-  virtual CommaExprNode *add_to_list(ExpressionNode *);
-  virtual CommaExprNode *clone() const { return new CommaExprNode( *this ); }
-};
-
-class ForCtlExprNode : public ExpressionNode {
-public:
-  ForCtlExprNode(ParseNode *, ExpressionNode *, ExpressionNode *) throw (SemanticError);
-  ForCtlExprNode( const ForCtlExprNode &other );
-  ~ForCtlExprNode();
-
-  StatementNode *get_init() const { return init; }
-  ExpressionNode *get_condition() const { return condition; }
-  ExpressionNode *get_change() const { return change; }
-
-  virtual ForCtlExprNode *clone() const { return new ForCtlExprNode( *this ); }
-  virtual Expression *build() const;
-
-  virtual void print( std::ostream &, int indent = 0 ) const;
-  virtual void printOneLine( std::ostream &, int indent = 0 ) const;
-private:
-  StatementNode *init;
-  ExpressionNode *condition;
-  ExpressionNode *change;
-};
-
-class ValofExprNode : public ExpressionNode {
-public:
-  ValofExprNode();
-  ValofExprNode( StatementNode *s = 0 );
-  ValofExprNode( const ValofExprNode &other );
-  ~ValofExprNode();
-  
-  virtual ValofExprNode *clone() const { return new ValofExprNode( *this ); }
-
-  StatementNode *get_body() const { return body; }
-  void print( std::ostream &, int indent = 0 ) const;
-  void printOneLine( std::ostream &, int indent = 0 ) const;
-  Expression *build() const;
-
-private:
-  StatementNode *body;
+    virtual ValofExprNode *clone() const { return new ValofExprNode( *this ); }
+
+    StatementNode *get_body() const { return body; }
+    void print( std::ostream &, int indent = 0 ) const;
+    void printOneLine( std::ostream &, int indent = 0 ) const;
+    Expression *build() const;
+
+  private:
+    StatementNode *body;
 };
 
 class TypeData;
 
-class DeclarationNode : public ParseNode
-{
-public:
-  enum Qualifier { Const, Restrict, Volatile, Lvalue };
-  enum StorageClass { Static, Auto, Extern, Register, Inline, Fortran };
-  enum BasicType { Char, Int, Float, Double, Void, Bool, Complex, Imaginary };
-  enum Modifier { Signed, Unsigned, Short, Long };
-  enum TyCon { Struct, Union, Context };
-  enum TypeClass { Type, Dtype, Ftype };
-
-  static const char *qualifierName[];
-  static const char *basicTypeName[];
-  static const char *modifierName[];
-  static const char *tyConName[];
-  static const char *typeClassName[];
-
-  static DeclarationNode *newFunction( std::string* name, DeclarationNode *ret, DeclarationNode *param,
-                                       StatementNode *body, bool newStyle = false );
-  static DeclarationNode *newQualifier( Qualifier );
-  static DeclarationNode *newStorageClass( StorageClass );
-  static DeclarationNode *newBasicType( BasicType );
-  static DeclarationNode *newModifier( Modifier );
-  static DeclarationNode *newForall( DeclarationNode* );
-  static DeclarationNode *newFromTypedef( std::string* );
-  static DeclarationNode *newAggregate( TyCon kind, std::string* name, DeclarationNode *formals, ExpressionNode *actuals, DeclarationNode *fields );
-  static DeclarationNode *newEnum( std::string *name, DeclarationNode *constants );
-  static DeclarationNode *newEnumConstant( std::string* name, ExpressionNode *constant );
-  static DeclarationNode *newName( std::string* );
-  static DeclarationNode *newFromTypeGen( std::string*, ExpressionNode *params );
-  static DeclarationNode *newTypeParam( TypeClass, std::string* );
-  static DeclarationNode *newContext( std::string *name, DeclarationNode *params, DeclarationNode *asserts );
-  static DeclarationNode *newContextUse( std::string *name, ExpressionNode *params );
-  static DeclarationNode *newTypeDecl( std::string *name, DeclarationNode *typeParams );
-  static DeclarationNode *newPointer( DeclarationNode *qualifiers );
-  static DeclarationNode *newArray( ExpressionNode *size, DeclarationNode *qualifiers, bool isStatic );
-  static DeclarationNode *newVarArray( DeclarationNode *qualifiers );
-  static DeclarationNode *newBitfield( ExpressionNode *size );
-  static DeclarationNode *newTuple( DeclarationNode *members );
-  static DeclarationNode *newTypeof( ExpressionNode *expr );
-  static DeclarationNode *newAttr( std::string*, ExpressionNode *expr );
-  static DeclarationNode *newAttr( std::string*, DeclarationNode *type );
-
-  DeclarationNode *addQualifiers( DeclarationNode* );
-  DeclarationNode *copyStorageClasses( DeclarationNode* );
-  DeclarationNode *addType( DeclarationNode* );
-  DeclarationNode *addTypedef();
-  DeclarationNode *addAssertions( DeclarationNode* );
-  DeclarationNode *addName( std::string* );
-  DeclarationNode *addBitfield( ExpressionNode *size );
-  DeclarationNode *addVarArgs();
-  DeclarationNode *addFunctionBody( StatementNode *body );
-  DeclarationNode *addOldDeclList( DeclarationNode *list );
-  DeclarationNode *addPointer( DeclarationNode *qualifiers );
-  DeclarationNode *addArray( DeclarationNode *array );
-  DeclarationNode *addNewPointer( DeclarationNode *pointer );
-  DeclarationNode *addNewArray( DeclarationNode *array );
-  DeclarationNode *addParamList( DeclarationNode *list );
-  DeclarationNode *addIdList( DeclarationNode *list );       // old-style functions
-  DeclarationNode *addInitializer( InitializerNode *init );
-
-  DeclarationNode *cloneType( std::string *newName );
-  DeclarationNode *cloneType( DeclarationNode *existing );
-  DeclarationNode *cloneType( int ) { return cloneType( (std::string*)0 ); }
-  DeclarationNode *cloneBaseType( std::string *newName );
-  DeclarationNode *cloneBaseType( DeclarationNode *newdecl );
-
-  DeclarationNode *appendList( DeclarationNode * );
-
-  DeclarationNode *clone() const;
-  void print( std::ostream &, int indent = 0 ) const;
-  void printList( std::ostream &, int indent = 0 ) const;
-
-  Declaration *build() const;
-  ::Type *buildType() const;
-
-  bool get_hasEllipsis() const;
-  std::string get_name() const { return name; }
-  LinkageSpec::Type get_linkage() const { return linkage; }
-  DeclarationNode *extractAggregate() const;
-
-  DeclarationNode();
-  ~DeclarationNode();
-private:
-  Declaration::StorageClass buildStorageClass() const;
-  bool buildInline() const;
-
-  TypeData *type;
-  std::string name;
-  std::list< StorageClass > storageClasses;
-  ExpressionNode *bitfieldWidth;
-  InitializerNode *initializer;
-  bool hasEllipsis;
-  LinkageSpec::Type linkage;
-
-  static UniqueName anonymous;
+class DeclarationNode : public ParseNode {
+  public:
+    enum Qualifier { Const, Restrict, Volatile, Lvalue, Atomic };
+    enum StorageClass { Static, Auto, Extern, Register, Inline, Fortran };
+    enum BasicType { Char, Int, Float, Double, Void, Bool, Complex, Imaginary };
+    enum Modifier { Signed, Unsigned, Short, Long };
+    enum TyCon { Struct, Union, Context };
+    enum TypeClass { Type, Dtype, Ftype };
+
+    static const char *qualifierName[];
+    static const char *basicTypeName[];
+    static const char *modifierName[];
+    static const char *tyConName[];
+    static const char *typeClassName[];
+
+    static DeclarationNode *newFunction( std::string *name, DeclarationNode *ret, DeclarationNode *param,
+                                         StatementNode *body, bool newStyle = false );
+    static DeclarationNode *newQualifier( Qualifier );
+    static DeclarationNode *newStorageClass( StorageClass );
+    static DeclarationNode *newBasicType( BasicType );
+    static DeclarationNode *newModifier( Modifier );
+    static DeclarationNode *newForall( DeclarationNode *);
+    static DeclarationNode *newFromTypedef( std::string *);
+    static DeclarationNode *newAggregate( TyCon kind, std::string *name, DeclarationNode *formals, ExpressionNode *actuals, DeclarationNode *fields );
+    static DeclarationNode *newEnum( std::string *name, DeclarationNode *constants );
+    static DeclarationNode *newEnumConstant( std::string *name, ExpressionNode *constant );
+    static DeclarationNode *newName( std::string *);
+    static DeclarationNode *newFromTypeGen( std::string*, ExpressionNode *params );
+    static DeclarationNode *newTypeParam( TypeClass, std::string *);
+    static DeclarationNode *newContext( std::string *name, DeclarationNode *params, DeclarationNode *asserts );
+    static DeclarationNode *newContextUse( std::string *name, ExpressionNode *params );
+    static DeclarationNode *newTypeDecl( std::string *name, DeclarationNode *typeParams );
+    static DeclarationNode *newPointer( DeclarationNode *qualifiers );
+    static DeclarationNode *newArray( ExpressionNode *size, DeclarationNode *qualifiers, bool isStatic );
+    static DeclarationNode *newVarArray( DeclarationNode *qualifiers );
+    static DeclarationNode *newBitfield( ExpressionNode *size );
+    static DeclarationNode *newTuple( DeclarationNode *members );
+    static DeclarationNode *newTypeof( ExpressionNode *expr );
+    static DeclarationNode *newAttr( std::string*, ExpressionNode *expr );
+    static DeclarationNode *newAttr( std::string*, DeclarationNode *type );
+
+    DeclarationNode *addQualifiers( DeclarationNode *);
+    DeclarationNode *copyStorageClasses( DeclarationNode *);
+    DeclarationNode *addType( DeclarationNode *);
+    DeclarationNode *addTypedef();
+    DeclarationNode *addAssertions( DeclarationNode *);
+    DeclarationNode *addName( std::string *);
+    DeclarationNode *addBitfield( ExpressionNode *size );
+    DeclarationNode *addVarArgs();
+    DeclarationNode *addFunctionBody( StatementNode *body );
+    DeclarationNode *addOldDeclList( DeclarationNode *list );
+    DeclarationNode *addPointer( DeclarationNode *qualifiers );
+    DeclarationNode *addArray( DeclarationNode *array );
+    DeclarationNode *addNewPointer( DeclarationNode *pointer );
+    DeclarationNode *addNewArray( DeclarationNode *array );
+    DeclarationNode *addParamList( DeclarationNode *list );
+    DeclarationNode *addIdList( DeclarationNode *list );       // old-style functions
+    DeclarationNode *addInitializer( InitializerNode *init );
+
+    DeclarationNode *cloneType( std::string *newName );
+    DeclarationNode *cloneType( DeclarationNode *existing );
+    DeclarationNode *cloneType( int ) { return cloneType( ( std::string *)0 ); }
+    DeclarationNode *cloneBaseType( std::string *newName );
+    DeclarationNode *cloneBaseType( DeclarationNode *newdecl );
+
+    DeclarationNode *appendList( DeclarationNode  *);
+
+    DeclarationNode *clone() const;
+    void print( std::ostream &, int indent = 0 ) const;
+    void printList( std::ostream &, int indent = 0 ) const;
+
+    Declaration *build() const;
+    ::Type *buildType() const;
+
+    bool get_hasEllipsis() const;
+    std::string get_name() const { return name; }
+    LinkageSpec::Type get_linkage() const { return linkage; }
+    DeclarationNode *extractAggregate() const;
+
+    DeclarationNode();
+    ~DeclarationNode();
+  private:
+    Declaration::StorageClass buildStorageClass() const;
+    bool buildInline() const;
+
+    TypeData *type;
+    std::string name;
+    std::list< StorageClass > storageClasses;
+    ExpressionNode *bitfieldWidth;
+    InitializerNode *initializer;
+    bool hasEllipsis;
+    LinkageSpec::Type linkage;
+
+    static UniqueName anonymous;
 };
 
 class StatementNode : public ParseNode {
-public:
-  enum Type { Exp,   If,        Switch,  Case,    Default,  Choose,   Fallthru, 
-              While, Do,        For,
-              Goto,  Continue,  Break,   Return,  Throw,
-              Try,   Catch,     Finally, Asm,
-              Decl
-            };
-
-  StatementNode( void );
-  StatementNode( std::string );
-  StatementNode( Type, ExpressionNode *e = 0, StatementNode *s = 0 );
-  StatementNode( Type, std::string *target );
-  StatementNode( DeclarationNode *decl );
-
-
-  ~StatementNode(void);
-
-  static StatementNode * newCatchStmt(DeclarationNode *d = 0, StatementNode *s = 0, bool catchRestP = false );
-
-  void set_control(ExpressionNode *);
-  StatementNode * set_block(StatementNode *);
-
-  ExpressionNode *get_control() const ;
-  StatementNode *get_block() const;
-  StatementNode::Type get_type(void) const;
-
-  StatementNode *add_label(std::string *);
-  std::list<std::string> *get_labels() const;
-
-  void addDeclaration( DeclarationNode *newDecl ) { decl = newDecl; }
-  void setCatchRest( bool newVal ) { isCatchRest = newVal; }
-
-  std::string get_target() const;
-
-  StatementNode *add_controlexp(ExpressionNode *);
-  StatementNode *append_block(StatementNode *);
-  StatementNode *append_last_case(StatementNode *);
-
-  void print( std::ostream &, int indent = 0) const;
-
-  virtual StatementNode *clone() const;
-
-  virtual Statement *build() const;
-
-private:
-  static const char *StType[];
-  Type type;
-  ExpressionNode *control;
-  StatementNode *block;
-  std::list<std::string> *labels;
-  std::string *target; // target label for jump statements
-  DeclarationNode *decl;
-
-  bool isCatchRest;
+  public:
+    enum Type { Exp,   If,        Switch,  Case,    Default,  Choose,   Fallthru, 
+                While, Do,        For,
+                Goto,  Continue,  Break,   Return,  Throw,
+                Try,   Catch,     Finally, Asm,
+                Decl
+    };
+
+    StatementNode( void );
+    StatementNode( std::string );
+    StatementNode( Type, ExpressionNode *e = 0, StatementNode *s = 0 );
+    StatementNode( Type, std::string *target );
+    StatementNode( DeclarationNode *decl );
+
+
+    ~StatementNode( void );
+
+    static StatementNode  *newCatchStmt( DeclarationNode *d = 0, StatementNode *s = 0, bool catchRestP = false );
+
+    void set_control( ExpressionNode * );
+    StatementNode * set_block( StatementNode * );
+
+    ExpressionNode *get_control() const ;
+    StatementNode *get_block() const;
+    StatementNode::Type get_type( void ) const;
+
+    StatementNode *add_label( std::string * );
+    std::list<std::string> *get_labels() const;
+
+    void addDeclaration( DeclarationNode *newDecl ) { decl = newDecl; }
+    void setCatchRest( bool newVal ) { isCatchRest = newVal; }
+
+    std::string get_target() const;
+
+    StatementNode *add_controlexp( ExpressionNode * );
+    StatementNode *append_block( StatementNode * );
+    StatementNode *append_last_case( StatementNode * );
+
+    void print( std::ostream &, int indent = 0) const;
+
+    virtual StatementNode *clone() const;
+
+    virtual Statement *build() const;
+  private:
+    static const char *StType[];
+    Type type;
+    ExpressionNode *control;
+    StatementNode *block;
+    std::list<std::string> *labels;
+    std::string *target;                                // target label for jump statements
+    DeclarationNode *decl;
+
+    bool isCatchRest;
 };
 
 class CompoundStmtNode : public StatementNode {
-public:
-  CompoundStmtNode(void);
-  CompoundStmtNode(std::string *);
-  CompoundStmtNode(StatementNode *);
-  ~CompoundStmtNode();
-
-  void add_statement(StatementNode *);
-
-  void print( std::ostream &, int indent = 0 ) const;
-
-  virtual Statement *build() const;
-
-private:
-  StatementNode *first, *last;
+  public:
+    CompoundStmtNode( void );
+    CompoundStmtNode( std::string * );
+    CompoundStmtNode( StatementNode * );
+    ~CompoundStmtNode();
+
+    void add_statement( StatementNode * );
+
+    void print( std::ostream &, int indent = 0 ) const;
+
+    virtual Statement *build() const;
+  private:
+    StatementNode *first, *last;
 };
 
 class NullStmtNode : public CompoundStmtNode {
-public:
-  Statement *build() const;
-  void print(std::ostream &, int indent = 0) const;
+  public:
+    Statement *build() const;
+    void print( std::ostream &, int indent = 0) const;
 };
 
 class InitializerNode : public ParseNode {
-public:
-  InitializerNode( ExpressionNode *, bool aggrp = false,  ExpressionNode *des = 0 );
-  InitializerNode( InitializerNode *, bool aggrp = false, ExpressionNode *des = 0 );
-  ~InitializerNode();
-
-  ExpressionNode *get_expression() const { return expr; }
-
-  InitializerNode *set_designators( ExpressionNode *des ) { designator = des; return this; }
-  ExpressionNode *get_designators() const { return designator; }
-
-  InitializerNode *next_init() const { return kids; }
-
-  void print( std::ostream &, int indent = 0 ) const;
-  void printOneLine( std::ostream & ) const;
-
-  virtual Initializer *build() const;
-
-private:
-  ExpressionNode *expr;
-  bool aggregate;
-  ExpressionNode *designator; // may be list
-  InitializerNode *kids;
+  public:
+    InitializerNode( ExpressionNode *, bool aggrp = false,  ExpressionNode *des = 0 );
+    InitializerNode( InitializerNode *, bool aggrp = false, ExpressionNode *des = 0 );
+    ~InitializerNode();
+
+    ExpressionNode *get_expression() const { return expr; }
+
+    InitializerNode *set_designators( ExpressionNode *des ) { designator = des; return this; }
+    ExpressionNode *get_designators() const { return designator; }
+
+    InitializerNode *next_init() const { return kids; }
+
+    void print( std::ostream &, int indent = 0 ) const;
+    void printOneLine( std::ostream & ) const;
+
+    virtual Initializer *build() const;
+  private:
+    ExpressionNode *expr;
+    bool aggregate;
+    ExpressionNode *designator; // may be list
+    InitializerNode *kids;
 };
 
@@ -477 +462 @@
 template< typename SynTreeType, typename NodeType >
 void
-buildList( const NodeType *firstNode, std::list< SynTreeType* > &outputList )
+buildList( const NodeType *firstNode, std::list< SynTreeType *> &outputList )
 {
-  SemanticError errors;
-  std::back_insert_iterator< std::list< SynTreeType* > > out( outputList );
-  const NodeType *cur = firstNode;
-
-  while( cur ) {
-    try {
-      SynTreeType *result = dynamic_cast< SynTreeType* >( cur->build() );
-      if( result ) {
-        *out++ = result;
-      } else {
-      }
-    } catch( SemanticError &e ) {
-      errors.append( e );
-    }
-    cur = dynamic_cast< NodeType* >( cur->get_link() );
-  }
-  if( !errors.isEmpty() ) {
-    throw errors;
-  }
+    SemanticError errors;
+    std::back_insert_iterator< std::list< SynTreeType *> > out( outputList );
+    const NodeType *cur = firstNode;
+
+    while ( cur ) {
+        try {
+            SynTreeType *result = dynamic_cast< SynTreeType *>( cur->build() );
+            if ( result ) {
+                *out++ = result;
+            } else {
+            } // if
+        } catch( SemanticError &e ) {
+            errors.append( e );
+        } // try
+        cur = dynamic_cast< NodeType *>( cur->get_link() );
+    } // while
+    if ( !errors.isEmpty() ) {
+        throw errors;
+    } // if
 }
 
 // in DeclarationNode.cc
-void buildList( const DeclarationNode *firstNode, std::list< Declaration* > &outputList );
-void buildList( const DeclarationNode *firstNode, std::list< DeclarationWithType* > &outputList );
-void buildTypeList( const DeclarationNode *firstNode, std::list< Type* > &outputList );
+void buildList( const DeclarationNode *firstNode, std::list< Declaration *> &outputList );
+void buildList( const DeclarationNode *firstNode, std::list< DeclarationWithType *> &outputList );
+void buildTypeList( const DeclarationNode *firstNode, std::list< Type *> &outputList );
 
 // in ExpressionNode.cc
@@ -509 +494 @@
 ExpressionNode *tupleContents( ExpressionNode *tuple );
 
-#endif /* #ifndef PARSENODE_H */
+#endif // PARSENODE_H
 
 // Local Variables: //

translator/Parser/TypeData.cc

@@ -541 +541 @@
           case DeclarationNode::Lvalue:
             q.isLvalue = true;
+            break;
+          case DeclarationNode::Atomic:
+            q.isAtomic = true;
             break;
         }

translator/Parser/TypeData.h

@@ -3 +3 @@
 
 #include <list>
+
 #include "ParseNode.h"
-#include "SynTree/SynTree.h"
 #include "SynTree/Type.h"
-#include "SynTree/Declaration.h"
-#include "SemanticError.h"
-#include "LinkageSpec.h"
 
 struct TypeData {

translator/Parser/cfa.y

@@ -10 +10 @@
  * Created On       : Sat Sep  1 20:22:55 2001
  * Last Modified By : Peter A. Buhr
- * Last Modified On : Sat Jan 17 09:23:45 2015
- * Update Count     : 908
+ * Last Modified On : Wed Apr 15 15:11:16 2015
+ * Update Count     : 913
  */
 
@@ -1144 +1144 @@
         declaration_specifier declarator asm_name_opt initializer_opt
                 {
-                        typedefTable.addToEnclosingScope( TypedefTable::ID);
+                        typedefTable.addToEnclosingScope( TypedefTable::ID );
                         $$ = ($2->addType( $1 ))->addInitializer($4);
                 }
@@ -1201 +1201 @@
         | LVALUE                                        /* CFA */
                 { $$ = DeclarationNode::newQualifier( DeclarationNode::Lvalue ); }
+        | ATOMIC
+                { $$ = DeclarationNode::newQualifier( DeclarationNode::Atomic ); }
         | FORALL '(' 
                 {

translator/Parser/parseutility.cc

@@ -1 @@
-/*
- * This file is part of the Cforall project
- *
- * $Id: parseutility.cc,v 1.2 2005/08/29 20:14:15 rcbilson Exp $
- *
- */
-
 #include "parseutility.h"
 #include "SynTree/Type.h"
@@ -11 +4 @@
 
 
-Expression *
-notZeroExpr( Expression *orig )
-{
+Expression *notZeroExpr( Expression *orig ) {
       UntypedExpr *comparison = new UntypedExpr( new NameExpr( "?!=?" ) );
       comparison->get_args().push_back( orig );

translator/Parser/parseutility.h

@@ -1 @@
-/*
- * This file is part of the Cforall project
- *
- * $Id: parseutility.h,v 1.2 2005/08/29 20:14:15 rcbilson Exp $
- *
- */
-
 #ifndef PARSER_PARSEUTILITY_H
 #define PARSER_PARSEUTILITY_H
@@ -13 +6 @@
 Expression *notZeroExpr( Expression *orig );
 
-#endif /* #ifndef PARSER_PARSEUTILITY_H */
+#endif // PARSER_PARSEUTILITY_H

translator/ResolvExpr/AlternativeFinder.cc

@@ -756 +756 @@
             alternatives.push_back( Alternative( sizeofExpr->clone(), env, Cost::zero ) );
         } else {
+            // find all alternatives for the argument to sizeof
             AlternativeFinder finder( indexer, env );
             finder.find( sizeofExpr->get_expr() );
-            if ( finder.alternatives.size() != 1 ) {
+            // find the lowest cost alternative among the alternatives, otherwise ambiguous
+            AltList winners;
+            findMinCost( finder.alternatives.begin(), finder.alternatives.end(), back_inserter( winners ) );
+            if ( winners.size() != 1 ) {
                 throw SemanticError( "Ambiguous expression in sizeof operand: ", sizeofExpr->get_expr() );
             }
-            Alternative &choice = finder.alternatives.front();
+            // return the lowest cost alternative for the argument
+            Alternative &choice = winners.front();
             alternatives.push_back( Alternative( new SizeofExpr( choice.expr->clone() ), choice.env, Cost::zero ) );
         }

translator/ResolvExpr/Resolver.cc

@@ -44 +44 @@
         acceptAll( translationUnit, resolver );
 #if 0
+        resolver.print( cerr );
         for ( std::list< Declaration * >::iterator i = translationUnit.begin(); i != translationUnit.end(); ++i ) {
             (*i)->print( std::cerr );
@@ -241 +242 @@
     void Resolver::visit( SingleInit *singleInit ) {
         if ( singleInit->get_value() ) {
+#if 0
+            if (NameExpr * ne = dynamic_cast<NameExpr*>(singleInit->get_value())) {
+                string n = ne->get_name();
+                if (n == "0") {
+                    initContext = new BasicType(Type::Qualifiers(), 
+                                                BasicType::SignedInt);
+                } else {
+                    DeclarationWithType * decl = lookupId(n);
+                    initContext = decl->get_type();
+                }
+            } else if (ConstantExpr * e = 
+                       dynamic_cast<ConstantExpr*>(singleInit->get_value())) {
+                Constant *c = e->get_constant();
+                initContext = c->get_type();
+            } else {
+                assert(0);
+            }
+#endif
             CastExpr *castExpr = new CastExpr( singleInit->get_value(), initContext->clone() );
             Expression *newExpr = findSingleExpression( castExpr, *this );
@@ -250 +269 @@
 
     void Resolver::visit( ListInit *listInit ) {
+        Visitor::visit(listInit);
+#if 0
         if ( ArrayType *at = dynamic_cast<ArrayType*>(initContext) ) {
-            initContext = at->get_base();
-            Visitor::visit( listInit );
+            std::list<Initializer *>::iterator iter( listInit->begin_initializers() );
+            for ( ; iter != listInit->end_initializers(); ++iter ) {
+                initContext = at->get_base();
+                (*iter)->accept( *this );
+            } // for
         } else if ( StructInstType *st = dynamic_cast<StructInstType*>(initContext) ) {
             StructDecl *baseStruct = st->get_baseStruct();
@@ -295 +319 @@
             (*listInit->begin_initializers())->accept( *this );
         } // if
+#endif
     }
 } // namespace ResolvExpr

translator/SymTab/IdTable.cc

@@ -82 +82 @@
     }
   }
-  for( InnerTableType::const_iterator i = declTable.begin(); i != declTable.end(); ++i ) {
+  // ensure the set of routines with C linkage cannot be overloaded
+  for( InnerTableType::iterator i = declTable.begin(); i != declTable.end(); ++i ) {
     if( !i->second.empty() && i->second.top().first->get_linkage() == LinkageSpec::C && declTable.size() > 1 ) {
-      throw SemanticError( "invalid overload of C function ", i->second.top().first );
+        InnerTableType::iterator j = i;
+        for( j++; j != declTable.end(); ++j ) {
+          if( !j->second.empty() && j->second.top().first->get_linkage() == LinkageSpec::C ) {
+            throw SemanticError( "invalid overload of C function " );
+          }
+        }
     }
   }
@@ -103 +109 @@
 }
 
+DeclarationWithType* IdTable::lookupId( const std::string &id) const {
+   DeclarationWithType* result = 0;
+   int depth = -1;
+
+   OuterTableType::const_iterator outer = table.find( id );
+   if( outer == table.end() ) return 0;
+   const InnerTableType &declTable = outer->second;
+   for( InnerTableType::const_iterator it = declTable.begin(); it != declTable.end(); ++it ) {
+     const std::stack< DeclEntry >& entry = it->second;
+     if( !entry.empty() && entry.top().second > depth ) {
+       result = entry.top().first;
+       depth = entry.top().second;
+     }
+   }
+   return result;
+}
+
 void 
 IdTable::dump( std::ostream &os ) const
 {
+  for( OuterTableType::const_iterator outer = table.begin(); outer != table.end(); ++outer ) {
+    for( InnerTableType::const_iterator inner = outer->second.begin(); inner != outer->second.end(); ++inner ) {
+#if 0
+      const std::stack< DeclEntry >& entry = inner->second;
+      if( !entry.empty() ) { // && entry.top().second == scopeLevel ) {
+        os << outer->first << " (" << inner->first << ") (" << entry.top().second << ")" << std::endl;
+      } else {
+        os << outer->first << " (" << inner->first << ") ( entry-empty)" << std::endl;
+      }
+#endif
+#if 0
+      std::stack<DeclEntry> stack = inner->second;
+      os << "dumping a stack" << std::endl;
+      while (!stack.empty()) {
+        DeclEntry d = stack.top();
+        os << outer->first << " (" << inner->first << ") (" << d.second << ") " << std::endl;
+        stack.pop();
+      }
+#endif
+    }
+  }
+#if 0
   for( OuterTableType::const_iterator outer = table.begin(); outer != table.end(); ++outer ) {
     for( InnerTableType::const_iterator inner = outer->second.begin(); inner != outer->second.end(); ++inner ) {
@@ -114 +159 @@
     }
   }
+#endif
 }
 

translator/SymTab/IdTable.h

@@ -1 @@
-/*
- * This file is part of the Cforall project
- *
- * $Id: IdTable.h,v 1.4 2005/08/29 20:14:17 rcbilson Exp $
- *
- */
-
 #ifndef SYMTAB_IDTABLE_H
 #define SYMTAB_IDTABLE_H
@@ -17 +10 @@
 
 namespace SymTab {
+    class IdTable {
+      public:
+        IdTable();
+  
+        void enterScope();
+        void leaveScope();
+        void addDecl( DeclarationWithType *decl );
+        void lookupId( const std::string &id, std::list< DeclarationWithType* >& decls ) const;
+        DeclarationWithType* lookupId( const std::string &id) const;
+  
+        void dump( std::ostream &os ) const; // debugging
 
-class IdTable
-{
-public:
-  IdTable();
-  
-  void enterScope();
-  void leaveScope();
-  void addDecl( DeclarationWithType *decl );
-  void lookupId( const std::string &id, std::list< DeclarationWithType* >& decls ) const;
-  
-  void dump( std::ostream &os ) const; // debugging
+      private:
+        typedef std::pair< DeclarationWithType*, int > DeclEntry;
+        typedef std::map< std::string, std::stack< DeclEntry > > InnerTableType;
+        typedef std::map< std::string, InnerTableType > OuterTableType;
 
- private:
-  typedef std::pair< DeclarationWithType*, int > DeclEntry;
-  typedef std::map< std::string, std::stack< DeclEntry > > InnerTableType;
-  typedef std::map< std::string, InnerTableType > OuterTableType;
-
-  OuterTableType table;
-  int scopeLevel;
-};
-
+        OuterTableType table;
+        int scopeLevel;
+    };
 } // namespace SymTab
 
-#endif /* #ifndef SYMTAB_IDTABLE_H */
+#endif // SYMTAB_IDTABLE_H

translator/SymTab/Indexer.cc

@@ -162 +162 @@
     }
 
+    DeclarationWithType* Indexer::lookupId( const std::string &id) const {
+        return idTable.lookupId(id);
+    }
+
     NamedTypeDecl *Indexer::lookupType( const std::string &id ) const {
         return typeTable.lookup( id );
@@ -216 +220 @@
 
     void Indexer::print( std::ostream &os, int indent ) const {
+        using std::cerr;
+        using std::endl;
+
+        cerr << "===idTable===" << endl;
+        idTable.dump( os );
+        cerr << "===typeTable===" << endl;
+        typeTable.dump( os );
+        cerr << "===structTable===" << endl;
+        structTable.dump( os );
+        cerr << "===enumTable===" << endl;
+        enumTable.dump( os );
+        cerr << "===unionTable===" << endl;
+        unionTable.dump( os );
+        cerr << "===contextTable===" << endl;
+        contextTable.dump( os );
+#if 0
         idTable.dump( os );
         typeTable.dump( os );
@@ -222 +242 @@
         unionTable.dump( os );
         contextTable.dump( os );
+#endif
     }
 } // namespace SymTab

translator/SymTab/Indexer.h

@@ -39 +39 @@
 
         void lookupId( const std::string &id, std::list< DeclarationWithType* >& ) const;
+        DeclarationWithType* lookupId( const std::string &id) const;
         NamedTypeDecl *lookupType( const std::string &id ) const;
         StructDecl *lookupStruct( const std::string &id ) const;
@@ -58 +59 @@
 } // namespace SymTab
 
-#endif /* #ifndef SYMTAB_INDEXER_H */
+#endif // SYMTAB_INDEXER_H

translator/SymTab/Mangler.cc

@@ -226 +226 @@
             mangleName << "L";
         }
+        if ( type->get_isAtomic() ) {
+            mangleName << "A";
+        }
     }
 } // SymTab

translator/SymTab/Validate.cc

@@ -278 +278 @@
             ObjectDecl *obj = dynamic_cast< ObjectDecl * >( *i );
             assert( obj );
-            obj->set_type( new EnumInstType( Type::Qualifiers( true, false, false, false ), enumDecl->get_name() ) );
+            obj->set_type( new EnumInstType( Type::Qualifiers( true, false, false, false, false ), enumDecl->get_name() ) );
         } // for
         Parent::visit( enumDecl );

translator/SynTree/Initializer.cc

@@ -39 +39 @@
 }
 
-MemberInit::MemberInit( Expression *_value, std::string _member ) : member ( _member ), value ( _value ) {}
-
-MemberInit::~MemberInit() {}
-
-MemberInit * MemberInit::clone() const {
-    return new MemberInit( *this );
-}
-
-void MemberInit::print( std::ostream &os, int indent ) {
-    os << "Member Initializer";
-    value->print( os, indent+2 );
-}
-
 ListInit::ListInit( std::list<Initializer*> &_initializers, std::list<Expression *> &_designators )
     : initializers( _initializers ), designators( _designators ) {

translator/SynTree/Initializer.h

@@ -61 +61 @@
 };
 
-// MemberInit represents an initializer for a member of an aggregate object (e.g., struct q { int a; } x = { a : 4 } )
-class MemberInit : public Initializer {
-  public:
-    MemberInit( Expression *value, std::string member = std::string("") );
-    virtual ~MemberInit();
-    
-    std::string get_member() { return member; }
-    void set_member( std::string newValue ) { member = newValue; }
-    Expression *get_value() { return value; }
-    void set_value( Expression *newValue ) { value = newValue; }
-
-    virtual MemberInit *clone() const;
-    virtual void accept( Visitor &v ) { v.visit( this ); }
-    virtual Initializer *acceptMutator( Mutator &m ) { return m.mutate( this ); }
-    virtual void print( std::ostream &os, int indent = 0 );
-  private:
-    std::string member;
-    Expression *value;
-};
-
-// ElementInit represents an initializer of an element of an array (e.g., [10] int x = { [7] : 4 }
-class ElementInit : public Initializer {
-  public:
-    ElementInit( Expression *value );
-    virtual ~ElementInit();
-    
-    int get_index() { return index; }
-    void set_index( int newValue ) { index = newValue; }
-    Expression *get_value() { return value; }
-    void set_value( Expression *newValue ) { value = newValue; }
-
-    virtual ElementInit *clone() const;
-    virtual void accept( Visitor &v ) { v.visit( this ); }
-    virtual Initializer *acceptMutator( Mutator &m ) { return m.mutate( this ); }
-    virtual void print( std::ostream &os, int indent = 0 );
-  private:
-    int index;
-    Expression *value;
-};
-
 // ListInit represents an initializer that is composed recursively of a list of initializers; this is used to initialize
 // an array or aggregate

translator/SynTree/Mutator.cc

@@ -368 +368 @@
 }
 
-Initializer *Mutator::mutate( MemberInit *memberInit ) {
-    memberInit->set_value( memberInit->get_value()->acceptMutator( *this ) );
-    return memberInit;
-}
-
-Initializer *Mutator::mutate( ElementInit *elementInit ) {
-    elementInit->set_value( elementInit->get_value()->acceptMutator( *this ) );
-    return elementInit;
-}
-
 Initializer *Mutator::mutate( SingleInit *singleInit ) {
     singleInit->set_value( singleInit->get_value()->acceptMutator( *this ) );

translator/SynTree/Mutator.h

@@ -72 +72 @@
     virtual Type* mutate( AttrType *attrType );
 
-    virtual Initializer* mutate( MemberInit *memberInit );
-    virtual Initializer* mutate( ElementInit *elementInit );
     virtual Initializer* mutate( SingleInit *singleInit );
     virtual Initializer* mutate( ListInit *listInit );

translator/SynTree/SynTree.h

@@ -89 +89 @@
 
 class Initializer;
-class MemberInit;
-class ElementInit;
 class SingleInit;
 class ListInit;

translator/SynTree/Type.cc

@@ -57 +57 @@
         os << "lvalue ";
     } // if
+    if ( tq.isAtomic ) {
+        os << "_Atomic ";
+    } // if
 }

translator/SynTree/Type.h

@@ -10 +10 @@
   public:
     struct Qualifiers {  
-      Qualifiers(): isConst( false ), isVolatile( false ), isRestrict( false ), isLvalue( false ) {}
-      Qualifiers( bool isConst, bool isVolatile, bool isRestrict, bool isLvalue ): isConst( isConst ), isVolatile( isVolatile ), isRestrict( isRestrict ), isLvalue( isLvalue ) {}
+      Qualifiers(): isConst( false ), isVolatile( false ), isRestrict( false ), isLvalue( false ), isAtomic( false ) {}
+      Qualifiers( bool isConst, bool isVolatile, bool isRestrict, bool isLvalue, bool isAtomic ): isConst( isConst ), isVolatile( isVolatile ), isRestrict( isRestrict ), isLvalue( isLvalue ), isAtomic( isAtomic ) {}
         
         Qualifiers &operator+=( const Qualifiers &other );
@@ -27 +27 @@
         bool isRestrict;
         bool isLvalue;
+        bool isAtomic;
     };  
 
@@ -38 +39 @@
     bool get_isRestrict() { return tq.isRestrict; }
     bool get_isLvalue() { return tq.isLvalue; }
+    bool get_isAtomic() { return tq.isAtomic; }
     void set_isConst( bool newValue ) { tq.isConst = newValue; }
     void set_iisVolatile( bool newValue ) { tq.isVolatile = newValue; }
     void set_isRestrict( bool newValue ) { tq.isRestrict = newValue; }
     void set_isLvalue( bool newValue ) { tq.isLvalue = newValue; }
+    void set_isAtomic( bool newValue ) { tq.isAtomic = newValue; }
     std::list<TypeDecl*>& get_forall() { return forall; }
 
@@ -380 +383 @@
     isRestrict |= other.isRestrict;
     isLvalue |= other.isLvalue;
+    isAtomic |= other.isAtomic;
     return *this;
 }
@@ -387 +391 @@
     if ( other.isVolatile ) isVolatile = 0;
     if ( other.isRestrict ) isRestrict = 0;
+    if ( other.isAtomic ) isAtomic = 0;
     return *this;
 }
@@ -398 +403 @@
 inline bool Type::Qualifiers::operator==( const Qualifiers &other ) {
     return isConst == other.isConst
-    && isVolatile == other.isVolatile
-    && isRestrict == other.isRestrict;
-///         && isLvalue == other.isLvalue;
+        && isVolatile == other.isVolatile
+        && isRestrict == other.isRestrict
+//      && isLvalue == other.isLvalue
+        && isAtomic == other.isAtomic;
 }
 
@@ -406 +412 @@
     return isConst != other.isConst
         || isVolatile != other.isVolatile
-        || isRestrict != other.isRestrict;
-///         && isLvalue == other.isLvalue;
+        || isRestrict != other.isRestrict
+//      || isLvalue != other.isLvalue
+        || isAtomic != other.isAtomic;
 }
 
@@ -413 +420 @@
     return isConst <= other.isConst
         && isVolatile <= other.isVolatile
-        && isRestrict <= other.isRestrict;
-///         && isLvalue >= other.isLvalue;
+        && isRestrict <= other.isRestrict
+//      && isLvalue >= other.isLvalue
+        && isAtomic == other.isAtomic;
 }
 
@@ -420 +428 @@
     return isConst >= other.isConst
         && isVolatile >= other.isVolatile
-        && isRestrict >= other.isRestrict;
-///         && isLvalue <= other.isLvalue;
+        && isRestrict >= other.isRestrict
+//      && isLvalue <= other.isLvalue
+        && isAtomic == other.isAtomic;
 }
 

translator/SynTree/Visitor.cc

@@ -309 +309 @@
 }
 
-void Visitor::visit(MemberInit *memberInit) {
-    memberInit->get_value()->accept( *this );
-}
-
-void Visitor::visit(ElementInit *elementInit) {
-    elementInit->get_value()->accept( *this );
-}
-
 void Visitor::visit(SingleInit *singleInit) {
     singleInit->get_value()->accept( *this );

translator/SynTree/Visitor.h

@@ -72 +72 @@
     virtual void visit( AttrType *attrType );
 
-    virtual void visit( MemberInit *memberInit );
-    virtual void visit( ElementInit *elementInit );
     virtual void visit( SingleInit *singleInit );
     virtual void visit( ListInit *listInit );

translator/Tests/Parser/Constant0-1.c

@@ -5 +5 @@
 int 0;
 const int 0;
-static const int 0;
+//static const int 0;
 int 1;
 const int 1;
-static const int 1;
+//static const int 1;
 int 0, 1;
 const int 0, 1;
-static const int 0, 1;
+//static const int 0, 1;
 struct { int i; } 0;
 const struct { int i; } 1;
@@ -27 +27 @@
 * int x, 0;
 const * int x, 0;
-static const * int x, 0;
+//static const * int x, 0;
 * struct { int i; } 0;
 const * struct { int i; } 0;
 static const * struct { int i; } 0;
-static * int x, 0;
-static const * int x, 0;
+//static * int x, 0;
+//static const * int x, 0;
 const * * int x, 0;
+
+int main() {
+//int 1, * 0;
+//* int x, 0;
+}

translator/examples/includes.c

@@ -34 +34 @@
 #include <curses.h>
 #else
+#include <time.h>               // FAILS -- includes locale.h
 #endif // 0
 

translator/examples/min.c

@@ -10 +10 @@
 int main() {
     char c;
-    c = min( 'a', 'z' );
+    c = min( 'z', 'a' );
     printf( "minimum %d\n", c );
     int i;

translator/examples/square.c

@@ -12 +12 @@
 int main() {
     printf( "result of square of 5 is %d\n", square( 5 ) );
+    printf( "result of square of 5 is %f\n", square( 5.0 ) );
 }

translator/examples/sum.c

@@ -7 +7 @@
     T ?+?( T, T );
     T ?++( T * );
-    [T] ?+=?( T *, T );
+    T ?+=?( T *, T );
 };
 
 forall( type T | sumable( T ) )
 T sum( int n, T a[] ) {
-    T total = 0;                        // instantiate T, select 0
+    T total;                            // instantiate T, select 0
+    total = 0;
     for ( int i = 0; i < n; i += 1 )
         total = total + a[i];           // select +
@@ -18 +19 @@
 }
 
+// Required to satisfy sumable as char does not have addition.
+const char 0;
+char ?+?( char op1, char op2 ) { return op1 + op2; }
+char ?++( char *op ) { return *op + 1; }
+
+const double 0; // TEMPORARY, incorrect use of int 0
+
 int main() {
     const int size = 10, low = 0, High = 10;
-    int si, ai[10]; // size
+    int si = 0, ai[10]; // size
     int i;
     for ( i = low; i < High; i += 1 ) {
@@ -28 +36 @@
     printf( "sum from %d to %d is %d, check %d\n",
             low, High, sum( size, ai ), si );
-    double sd, ad[10]; // size
+
+//    char ci[10];
+//    char c = sum( size, ci );
+//    float fi[10];
+//    float f = sum( size, fi );
+
+    double sd = 0.0, ad[10]; // size
     for ( i = low; i < High; i += 1 ) {
         double d = i / (double)size;

translator/main.cc

@@ -48 +48 @@
     bool debugp = false, treep = false, astp = false, manglep = false, symtabp = false, validp = false;
     bool preludep = true, protop = false, libp = false;
-    bool exprp = false;
+    bool exprp = false, codegenp = false;
     int c;
     FILE *input, *prelude, *builtins;
@@ -55 +55 @@
     opterr = 0;
 
-    while ( (c = getopt( argc, argv, "dtsgmvxcenprlD:" )) != -1 ) {
+    while ( (c = getopt( argc, argv, "dtsgmvxcenprlDz:" )) != -1 ) {
         switch (c) {
           case 'd':
@@ -89 +89 @@
             exprp = true;
             break;
+          case 'z':
+            codegenp = true;
+            break;
           case 'n':
             /* don't read preamble */
@@ -234 +237 @@
             return 0;
         } // if
+
+        if ( codegenp ) {
+            // print the tree right before code generation...
+                        // InitTweak::mutate( translationUnit );
+            //            InitTweak::tweak( translationUnit );
+            //printAll( translationUnit, std::cout );
+
+            // std::cerr << "finished tweaking" << std::endl;
+            SymTab::validate( translationUnit, false );
+            ControlStruct::mutate( translationUnit );
+            CodeGen::fixNames( translationUnit );
+            ResolvExpr::resolve( translationUnit );
+            GenPoly::copyParams( translationUnit );
+            GenPoly::convertSpecializations( translationUnit );
+            GenPoly::convertLvalue( translationUnit );
+            GenPoly::box( translationUnit );
+            printAll( translationUnit, std::cout );
+            return 0;
+        } // if
 
         //std::cerr << "before validate" << std::endl;