Changeset 937e51d for src/CodeGen

Timestamp:

Jun 26, 2015, 4:00:26 PM (11 years ago)

Author:

Aaron Moss <a3moss@…>

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, stuck-waitfor-destruct, with_gc

Children:

0df292b, e0ff3e6

Parents:

eb50842 (diff), 1869adf (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge pointer to pointer to qualified fix into master

Location:

src/CodeGen

Files:

• CodeGenerator.cc (moved) (moved from src/CodeGen/CodeGenerator2.cc ) (18 diffs)
• CodeGenerator.h (moved) (moved from src/CodeGen/CodeGenerator2.h ) (6 diffs)
• GenType.cc (modified) (6 diffs)
• Generate.cc (modified) (3 diffs)
• OperatorTable.cc (modified) (2 diffs)
• OperatorTable.h (modified) (2 diffs)
• module.mk (modified) (1 diff)

src/CodeGen/CodeGenerator.cc

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// CodeGenerator2.cc -- 
+// CodeGenerator.cc -- 
 //
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Thu May 21 17:13:35 2015
-// Update Count     : 7
+// Last Modified By : Rob Schluntz
+// Last Modified On : Wed Jun 24 16:11:41 2015
+// Update Count     : 143
 //
 
@@ -19 +19 @@
 #include <list>
 
+#include "Parser/ParseNode.h"
+
 #include "SynTree/Type.h"
-#include "SynTree/Declaration.h"
-#include "SynTree/Statement.h"
 #include "SynTree/Expression.h"
 #include "SynTree/Initializer.h"
+#include "SynTree/Statement.h"
 
 #include "utility.h"
 #include "UnimplementedError.h"
 
-#include "CodeGenerator2.h"
+#include "CodeGenerator.h"
 #include "OperatorTable.h"
 #include "GenType.h"
@@ -35 +36 @@
 
 namespace CodeGen {
-        int CodeGenerator2::tabsize = 4;
-
-        CodeGenerator2::CodeGenerator2( std::ostream &os ) : cur_indent( 0 ), insideFunction( false ), before( os ), after() { }
-
-        CodeGenerator2::CodeGenerator2( std::ostream &os, std::string init, int indent, bool infunp )
-                : cur_indent( indent ), insideFunction( infunp ), before( os ) {
-                //before << std::string( init );
-        }
-
-        CodeGenerator2::CodeGenerator2( std::ostream &os, char *init, int indent, bool infunp )
-                : cur_indent( indent ), insideFunction( infunp ), before( os ) {
-                //before << std::string( init );
+        int CodeGenerator::tabsize = 4;
+
+        // the kinds of statements that would ideally be separated by more whitespace
+        bool wantSpacing( Statement * stmt) {
+                return dynamic_cast< IfStmt * >( stmt ) || dynamic_cast< CompoundStmt * >( stmt ) ||
+                        dynamic_cast< WhileStmt * >( stmt ) || dynamic_cast< ForStmt * > ( stmt ) || dynamic_cast< SwitchStmt *>( stmt );
+        }
+
+        ostream & CodeGenerator::Indenter::operator()( ostream & output ) {
+          return output << string( cg.cur_indent, ' ' );
+        }
+
+        ostream & operator<<( ostream & output, CodeGenerator::Indenter &indent ) {
+                return indent( output );
+        }
+
+        CodeGenerator::CodeGenerator( std::ostream &os ) : indent(*this), cur_indent( 0 ), insideFunction( false ), output( os ) { }
+
+        CodeGenerator::CodeGenerator( std::ostream &os, std::string init, int indentation, bool infunp )
+                        : indent(*this), cur_indent( indentation ), insideFunction( infunp ), output( os ) {
+                //output << std::string( init );
+        }
+
+        CodeGenerator::CodeGenerator( std::ostream &os, char *init, int indentation, bool infunp )
+                        : indent(*this), cur_indent( indentation ), insideFunction( infunp ), output( os ) {
+                //output << std::string( init );
         }
 
@@ -56 +71 @@
                 } // if
         }
-  
+
         //*** Declarations
-        void CodeGenerator2::visit( FunctionDecl *functionDecl ) {
+        void CodeGenerator::visit( FunctionDecl *functionDecl ) {
                 handleStorageClass( functionDecl );
-                before << genType( functionDecl->get_functionType(), mangleName( functionDecl ) );
+                if ( functionDecl->get_isInline() ) {
+                        output << "inline ";
+                } // if
+                if ( functionDecl->get_isNoreturn() ) {
+                        output << "_Noreturn ";
+                } // if
+                output << genType( functionDecl->get_functionType(), mangleName( functionDecl ) );
 
                 // how to get this to the Functype?
                 std::list< Declaration * > olds = functionDecl->get_oldDecls();
                 if ( ! olds.empty() ) {
-                        before << " /* function has old declaration */";
+                        output << " /* function has old declaration */";
                 } // if
 
@@ -74 +95 @@
         }
 
-        void CodeGenerator2::visit( ObjectDecl *objectDecl ) {
+        void CodeGenerator::visit( ObjectDecl *objectDecl ) {
                 handleStorageClass( objectDecl );
-                before << genType( objectDecl->get_type(), mangleName( objectDecl ) );
+                output << genType( objectDecl->get_type(), mangleName( objectDecl ) );
         
                 if ( objectDecl->get_init() ) {
-                        before << " = ";
+                        output << " = ";
                         objectDecl->get_init()->accept( *this );
                 } // if
                 if ( objectDecl->get_bitfieldWidth() ) {
-                        before << ":";
+                        output << ":";
                         objectDecl->get_bitfieldWidth()->accept( *this );
                 } // if
         }
 
-        void CodeGenerator2::handleAggregate( AggregateDecl *aggDecl ) {
+        void CodeGenerator::handleAggregate( AggregateDecl *aggDecl ) {
                 if ( aggDecl->get_name() != "" )
-                        before << aggDecl->get_name();
+                        output << aggDecl->get_name();
         
                 std::list< Declaration * > &memb = aggDecl->get_members();
 
                 if ( ! memb.empty() ) {
-                        before << endl << string( cur_indent, ' ' ) << "{" << endl;
-
-                        cur_indent += CodeGenerator2::tabsize; 
+                        output << " {" << endl;
+
+                        cur_indent += CodeGenerator::tabsize; 
                         for ( std::list< Declaration* >::iterator i = memb.begin(); i != memb.end();  i++) {
-                                before << string( cur_indent, ' ' ); 
+                                output << indent; 
                                 (*i)->accept(*this );
-                                before << ";" << endl;
+                                output << ";" << endl;
                         }
 
-                        cur_indent -= CodeGenerator2::tabsize; 
-
-                        before << string( cur_indent, ' ' ) << "}";
-                } // if
-        }
-
-        void CodeGenerator2::visit( StructDecl *structDecl ) {
-                before << "struct ";
+                        cur_indent -= CodeGenerator::tabsize; 
+
+                        output << indent << "}";
+                } // if
+        }
+
+        void CodeGenerator::visit( StructDecl *structDecl ) {
+                output << "struct ";
                 handleAggregate( structDecl );
         }
 
-        void CodeGenerator2::visit( UnionDecl *aggregateDecl ) {
-                before << "union ";
+        void CodeGenerator::visit( UnionDecl *aggregateDecl ) {
+                output << "union ";
                 handleAggregate( aggregateDecl );
         }
   
-        void CodeGenerator2::visit( EnumDecl *aggDecl ) {
-                before << "enum ";
+        void CodeGenerator::visit( EnumDecl *aggDecl ) {
+                output << "enum ";
 
                 if ( aggDecl->get_name() != "" )
-                        before << aggDecl->get_name();
+                        output << aggDecl->get_name();
         
                 std::list< Declaration* > &memb = aggDecl->get_members();
 
                 if ( ! memb.empty() ) {
-                        before << endl << "{" << endl;
-
-                        cur_indent += CodeGenerator2::tabsize; 
+                        output << " {" << endl;
+
+                        cur_indent += CodeGenerator::tabsize; 
                         for ( std::list< Declaration* >::iterator i = memb.begin(); i != memb.end();  i++) {
                                 ObjectDecl *obj = dynamic_cast< ObjectDecl* >( *i );
                                 assert( obj );
-                                before << string( cur_indent, ' ' ) << mangleName( obj ); 
+                                output << indent << mangleName( obj ); 
                                 if ( obj->get_init() ) {
-                                        before << " = ";
+                                        output << " = ";
                                         obj->get_init()->accept(*this );
                                 } // if
-                                before << "," << endl;
+                                output << "," << endl;
                         } // for
 
-                        cur_indent -= CodeGenerator2::tabsize; 
-
-                        before << "}" << endl;
-                } // if
-        }
-  
-        void CodeGenerator2::visit( ContextDecl *aggregateDecl ) {}
-  
-        void CodeGenerator2::visit( TypedefDecl *typeDecl ) {
-                before << "typedef ";
-                before << genType( typeDecl->get_base(), typeDecl->get_name() );
-        }
-  
-        void CodeGenerator2::visit( TypeDecl *typeDecl ) {
+                        cur_indent -= CodeGenerator::tabsize; 
+
+                        output << indent << "}";
+                } // if
+        }
+  
+        void CodeGenerator::visit( ContextDecl *aggregateDecl ) {}
+  
+        void CodeGenerator::visit( TypedefDecl *typeDecl ) {
+                output << "typedef ";
+                output << genType( typeDecl->get_base(), typeDecl->get_name() );
+        }
+  
+        void CodeGenerator::visit( TypeDecl *typeDecl ) {
                 // really, we should mutate this into something that isn't a TypeDecl but that requires large-scale changes,
                 // still to be done
-                before << "extern unsigned long " << typeDecl->get_name();
+                output << "extern unsigned long " << typeDecl->get_name();
                 if ( typeDecl->get_base() ) {
-                        before << " = sizeof( " << genType( typeDecl->get_base(), "" ) << " )";
-                } // if
-        }
-
-        void CodeGenerator2::visit( SingleInit *init ) {
+                        output << " = sizeof( " << genType( typeDecl->get_base(), "" ) << " )";
+                } // if
+        }
+
+        void CodeGenerator::visit( SingleInit *init ) {
                 init->get_value()->accept( *this );
         }
 
-        void CodeGenerator2::visit( ListInit *init ) {
-                before << "{ ";
+        void CodeGenerator::visit( ListInit *init ) {
+                output << "{ ";
                 genCommaList( init->begin_initializers(), init->end_initializers() );
-                before << " }";
-        }
-
-        void CodeGenerator2::visit( Constant *constant ) { 
-                before << constant->get_value() ;
+                output << " }";
+        }
+
+        void CodeGenerator::visit( Constant *constant ) { 
+                output << constant->get_value() ;
         }
 
         //*** Expressions
-        void CodeGenerator2::visit( ApplicationExpr *applicationExpr ) {
+        void CodeGenerator::visit( ApplicationExpr *applicationExpr ) {
                 if ( VariableExpr *varExpr = dynamic_cast< VariableExpr* >( applicationExpr->get_function() ) ) {
                         OperatorInfo opInfo;
@@ -211 +232 @@
                                         assert( applicationExpr->get_args().size() == 2 );
                                         (*arg++)->accept( *this );
-                                        before << "[";
-                                        (*arg)->accept( *this );
-                                        before << "]";
+                                        output << "[";
+                                        (*arg)->accept( *this );
+                                        output << "]";
                                         break;
               
@@ -224 +245 @@
                                   case OT_PREFIXASSIGN:
                                         assert( applicationExpr->get_args().size() == 1 );
-                                        before << "(";
-                                        before << opInfo.symbol;
-                                        (*arg)->accept( *this );
-                                        before << ")";
+                                        output << "(";
+                                        output << opInfo.symbol;
+                                        (*arg)->accept( *this );
+                                        output << ")";
                                         break;
               
@@ -234 +255 @@
                                         assert( applicationExpr->get_args().size() == 1 );
                                         (*arg)->accept( *this );
-                                        before << opInfo.symbol;
+                                        output << opInfo.symbol;
                                         break;
 
@@ -240 +261 @@
                                   case OT_INFIXASSIGN:
                                         assert( applicationExpr->get_args().size() == 2 );
-                                        before << "(";
+                                        output << "(";
                                         (*arg++)->accept( *this );
-                                        before << opInfo.symbol;
-                                        (*arg)->accept( *this );
-                                        before << ")";
+                                        output << opInfo.symbol;
+                                        (*arg)->accept( *this );
+                                        output << ")";
                                         break;
               
@@ -253 +274 @@
                         } else {
                                 varExpr->accept( *this );
-                                before << "(";
+                                output << "(";
                                 genCommaList( applicationExpr->get_args().begin(), applicationExpr->get_args().end() );
-                                before << ")";
+                                output << ")";
                         } // if
                 } else {
                         applicationExpr->get_function()->accept( *this );
-                        before << "(";
+                        output << "(";
                         genCommaList( applicationExpr->get_args().begin(), applicationExpr->get_args().end() );
-                        before << ")";
-                } // if
-        }
-  
-        void CodeGenerator2::visit( UntypedExpr *untypedExpr ) {
+                        output << ")";
+                } // if
+        }
+  
+        void CodeGenerator::visit( UntypedExpr *untypedExpr ) {
                 if ( NameExpr *nameExpr = dynamic_cast< NameExpr* >( untypedExpr->get_function() ) ) {
                         OperatorInfo opInfo;
@@ -274 +295 @@
                                         assert( untypedExpr->get_args().size() == 2 );
                                         (*arg++)->accept( *this );
-                                        before << "[";
-                                        (*arg)->accept( *this );
-                                        before << "]";
+                                        output << "[";
+                                        (*arg)->accept( *this );
+                                        output << "]";
                                         break;
               
@@ -285 +306 @@
                                   case OT_PREFIX:
                                   case OT_PREFIXASSIGN:
+                                  case OT_LABELADDRESS:
                                         assert( untypedExpr->get_args().size() == 1 );
-                                        before << "(";
-                                        before << opInfo.symbol;
-                                        (*arg)->accept( *this );
-                                        before << ")";
+                                        output << "(";
+                                        output << opInfo.symbol;
+                                        (*arg)->accept( *this );
+                                        output << ")";
                                         break;
               
@@ -296 +318 @@
                                         assert( untypedExpr->get_args().size() == 1 );
                                         (*arg)->accept( *this );
-                                        before << opInfo.symbol;
+                                        output << opInfo.symbol;
                                         break;
   
@@ -302 +324 @@
                                   case OT_INFIXASSIGN:
                                         assert( untypedExpr->get_args().size() == 2 );
-                                        before << "(";
+                                        output << "(";
                                         (*arg++)->accept( *this );
-                                        before << opInfo.symbol;
-                                        (*arg)->accept( *this );
-                                        before << ")";
-                                        break;
-              
+                                        output << opInfo.symbol;
+                                        (*arg)->accept( *this );
+                                        output << ")";
+                                        break;
+                                        
                                   case OT_CONSTANT:
                                         // there are no intrinsic definitions of 0 or 1 as functions
@@ -315 +337 @@
                         } else {
                                 nameExpr->accept( *this );
-                                before << "(";
+                                output << "(";
                                 genCommaList( untypedExpr->get_args().begin(), untypedExpr->get_args().end() );
-                                before << ")";
+                                output << ")";
                         } // if
                 } else {
                         untypedExpr->get_function()->accept( *this );
-                        before << "(";
+                        output << "(";
                         genCommaList( untypedExpr->get_args().begin(), untypedExpr->get_args().end() );
-                        before << ")";
-                } // if
-        }
-  
-        void CodeGenerator2::visit( NameExpr *nameExpr ) {
+                        output << ")";
+                } // if
+        }
+  
+        void CodeGenerator::visit( NameExpr *nameExpr ) {
                 OperatorInfo opInfo;
                 if ( operatorLookup( nameExpr->get_name(), opInfo ) ) {
                         assert( opInfo.type == OT_CONSTANT );
-                        before << opInfo.symbol;
-                } else {
-                        before << nameExpr->get_name();
-                } // if
-        }
-  
-        void CodeGenerator2::visit( AddressExpr *addressExpr ) {
-                before << "(&";
+                        output << opInfo.symbol;
+                } else {
+                        output << nameExpr->get_name();
+                } // if
+        }
+  
+        void CodeGenerator::visit( AddressExpr *addressExpr ) {
+                output << "(&";
                 // this hack makes sure that we don't convert "constant_zero" to "0" if we're taking its address
                 if ( VariableExpr *variableExpr = dynamic_cast< VariableExpr* >( addressExpr->get_arg() ) ) {
-                        before << mangleName( variableExpr->get_var() );
+                        output << mangleName( variableExpr->get_var() );
                 } else {
                         addressExpr->get_arg()->accept( *this );
                 } // if
-                before << ")";
-        }
-
-        void CodeGenerator2::visit( CastExpr *castExpr ) {
-                before << "((";
+                output << ")";
+        }
+
+        void CodeGenerator::visit( CastExpr *castExpr ) {
+                output << "((";
                 if ( castExpr->get_results().empty() ) {
-                        before << "void" ;
-                } else {
-                        before << genType( castExpr->get_results().front(), "" );
-                } // if
-                before << ")";
+                        output << "void" ;
+                } else {
+                        output << genType( castExpr->get_results().front(), "" );
+                } // if
+                output << ")";
                 castExpr->get_arg()->accept( *this );
-                before << ")";
-        }
-  
-        void CodeGenerator2::visit( UntypedMemberExpr *memberExpr ) {
+                output << ")";
+        }
+  
+        void CodeGenerator::visit( UntypedMemberExpr *memberExpr ) {
                 assert( false );
         }
   
-        void CodeGenerator2::visit( MemberExpr *memberExpr ) {
+        void CodeGenerator::visit( MemberExpr *memberExpr ) {
                 memberExpr->get_aggregate()->accept( *this );
-                before << "." << mangleName( memberExpr->get_member() );
-        }
-  
-        void CodeGenerator2::visit( VariableExpr *variableExpr ) {
+                output << "." << mangleName( memberExpr->get_member() );
+        }
+  
+        void CodeGenerator::visit( VariableExpr *variableExpr ) {
                 OperatorInfo opInfo;
                 if ( variableExpr->get_var()->get_linkage() == LinkageSpec::Intrinsic && operatorLookup( variableExpr->get_var()->get_name(), opInfo ) && opInfo.type == OT_CONSTANT ) {
-                        before << opInfo.symbol;
-                } else {
-                        before << mangleName( variableExpr->get_var() );
-                } // if
-        }
-  
-        void CodeGenerator2::visit( ConstantExpr *constantExpr ) {
+                        output << opInfo.symbol;
+                } else {
+                        output << mangleName( variableExpr->get_var() );
+                } // if
+        }
+  
+        void CodeGenerator::visit( ConstantExpr *constantExpr ) {
                 assert( constantExpr->get_constant() );
                 constantExpr->get_constant()->accept( *this );
         }
   
-        void CodeGenerator2::visit( SizeofExpr *sizeofExpr ) {
-                before << "sizeof(";
+        void CodeGenerator::visit( SizeofExpr *sizeofExpr ) {
+                output << "sizeof(";
                 if ( sizeofExpr->get_isType() ) {
-                        before << genType( sizeofExpr->get_type(), "" );
+                        output << genType( sizeofExpr->get_type(), "" );
                 } else {
                         sizeofExpr->get_expr()->accept( *this );
                 } // if
-                before << ")";
-        }
-  
-        void CodeGenerator2::visit( LogicalExpr *logicalExpr ) {
-                before << "(";
+                output << ")";
+        }
+  
+        void CodeGenerator::visit( LogicalExpr *logicalExpr ) {
+                output << "(";
                 logicalExpr->get_arg1()->accept( *this );
                 if ( logicalExpr->get_isAnd() ) {
-                        before << " && ";
-                } else {
-                        before << " || ";
+                        output << " && ";
+                } else {
+                        output << " || ";
                 } // if
                 logicalExpr->get_arg2()->accept( *this );
-                before << ")";
-        }
-  
-        void CodeGenerator2::visit( ConditionalExpr *conditionalExpr ) {
-                before << "(";
+                output << ")";
+        }
+  
+        void CodeGenerator::visit( ConditionalExpr *conditionalExpr ) {
+                output << "(";
                 conditionalExpr->get_arg1()->accept( *this );
-                before << " ? ";
+                output << " ? ";
                 conditionalExpr->get_arg2()->accept( *this );
-                before << " : ";
+                output << " : ";
                 conditionalExpr->get_arg3()->accept( *this );
-                before << ")";
-        }
-  
-        void CodeGenerator2::visit( CommaExpr *commaExpr ) {
-                before << "(";
+                output << ")";
+        }
+  
+        void CodeGenerator::visit( CommaExpr *commaExpr ) {
+                output << "(";
                 commaExpr->get_arg1()->accept( *this );
-                before << " , ";
+                output << " , ";
                 commaExpr->get_arg2()->accept( *this );
-                before << ")";
-        }
-  
-        void CodeGenerator2::visit( TupleExpr *tupleExpr ) {}
-  
-        void CodeGenerator2::visit( TypeExpr *typeExpr ) {}
-  
-  
+                output << ")";
+        }
+  
+        void CodeGenerator::visit( TupleExpr *tupleExpr ) {}
+  
+        void CodeGenerator::visit( TypeExpr *typeExpr ) {}
+
         //*** Statements
-        void CodeGenerator2::visit( CompoundStmt *compoundStmt ) {
+        void CodeGenerator::visit( CompoundStmt *compoundStmt ) {
                 std::list<Statement*> ks = compoundStmt->get_kids();
-
-                before << endl << string( cur_indent, ' ' ) << "{" << endl;
-
-                cur_indent += CodeGenerator2::tabsize; 
+                output << "{" << endl;
+
+                cur_indent += CodeGenerator::tabsize;
 
                 for ( std::list<Statement *>::iterator i = ks.begin(); i != ks.end();  i++) {
-                        before << string( cur_indent, ' ' ) << printLabels( (*i)->get_labels() )  ;
+                        output << indent << printLabels( (*i)->get_labels() );
                         (*i)->accept(*this );
-                        shift_left();
-                        before << endl;
+
+                        output << endl;
+                        if ( wantSpacing( *i ) ) {
+                                output << endl;
+                        }
                 }
-                cur_indent -= CodeGenerator2::tabsize; 
-
-                before << string( cur_indent, ' ' ) << "}" << endl;
-        }
-
-        void CodeGenerator2::visit( ExprStmt *exprStmt ) {
-                if ( exprStmt != 0 ) {
-                        exprStmt->get_expr()->accept( *this );
-                        shift_left();
-                        before << ";" ;
-                } // if
-        }
-
-        void CodeGenerator2::visit( IfStmt *ifStmt ) {
-                before << "if (";
+                cur_indent -= CodeGenerator::tabsize; 
+
+                output << indent << "}";
+        }
+
+        void CodeGenerator::visit( ExprStmt *exprStmt ) {
+                // I don't see why this check is necessary. 
+                // If this starts to cause problems then put it back in, 
+                // with an explanation
+                assert( exprStmt );
+
+                // if ( exprStmt != 0 ) {
+                exprStmt->get_expr()->accept( *this );
+                output << ";" ;
+                // } // if
+        }
+
+        void CodeGenerator::visit( IfStmt *ifStmt ) {
+                output << "if (";
                 ifStmt->get_condition()->accept(*this );
-                after += ")\n";
-                shift_left(); 
-
-                cur_indent += CodeGenerator2::tabsize;
-                before << string( cur_indent, ' ' );
+                output << ") ";
+
                 ifStmt->get_thenPart()->accept(*this );
-                cur_indent -= CodeGenerator2::tabsize; 
-                shift_left(); before << endl;
 
                 if ( ifStmt->get_elsePart() != 0) {
-                        before << string( cur_indent, ' ' ) << " else " << endl ;
-
-                        cur_indent += CodeGenerator2::tabsize; 
+                        output << " else ";
                         ifStmt->get_elsePart()->accept(*this );
-                        cur_indent -= CodeGenerator2::tabsize; 
-                } // if
-        }
-
-        void CodeGenerator2::visit( SwitchStmt *switchStmt ) {
-                //before << /* "\r" << */ string( cur_indent, ' ' ) << CodeGenerator2::printLabels( switchStmt->get_labels() ) 
-                before << "switch (" ;
+                } // if
+        }
+
+        void CodeGenerator::visit( SwitchStmt *switchStmt ) {
+                output << "switch (" ;
                 switchStmt->get_condition()->accept(*this );
-                after += ")\n";
-                shift_left();
-
-                before << string( cur_indent, ' ' ) << "{" << std::endl;
-                cur_indent += CodeGenerator2::tabsize;
-
-                std::list< Statement * > stmts = switchStmt->get_branches();
-                bool lastBreak = false; 
-
-                // horrible, horrible hack
-                if ( dynamic_cast<BranchStmt *>( stmts.back() ) != 0 ) {
-                        lastBreak = true;
-                        stmts.pop_back();
-                } // if
-                acceptAll( stmts, *this );
-                if ( lastBreak ) {
-                        Statement *st = switchStmt->get_branches().back();
-                        before << CodeGenerator2::printLabels( st->get_labels());
-                        st->accept( *this );
-                } // if
-          
-                cur_indent -= CodeGenerator2::tabsize; 
-
-                before << /* "\r" << */ string( cur_indent, ' ' ) << "}" << endl ;
-        }
-
-        void CodeGenerator2::visit( CaseStmt *caseStmt ) {
-                before << string( cur_indent, ' ' );
-                if ( caseStmt->isDefault()) 
-                        before << "default "  ;
-                else {
-                        before << "case "  ;
+                output << ") ";
+                
+                output << "{" << std::endl;
+                cur_indent += CodeGenerator::tabsize;
+
+                acceptAll( switchStmt->get_branches(), *this );
+
+                cur_indent -= CodeGenerator::tabsize;
+
+                output << indent << "}";
+        }
+
+        void CodeGenerator::visit( CaseStmt *caseStmt ) {
+                output << indent;
+                if ( caseStmt->isDefault()) {
+                        output << "default";
+                } else {
+                        output << "case ";
                         caseStmt->get_condition()->accept(*this );
                 } // if
-                after += ":\n";
-                shift_left();
-
+                output << ":\n";
+                
                 std::list<Statement *> sts = caseStmt->get_statements();
 
-                cur_indent += CodeGenerator2::tabsize;
+                cur_indent += CodeGenerator::tabsize;
                 for ( std::list<Statement *>::iterator i = sts.begin(); i != sts.end();  i++) {
-                        before << /* "\r" << */ string( cur_indent, ' ' ) << printLabels( (*i)->get_labels() )  ;
+                        output << indent << printLabels( (*i)->get_labels() )  ;
                         (*i)->accept(*this );
-                        shift_left();
-                        before << ";" << endl;
+                        output << endl;
                 }
-                cur_indent -= CodeGenerator2::tabsize;
-        }
-
-        void CodeGenerator2::visit( BranchStmt *branchStmt ) {
+                cur_indent -= CodeGenerator::tabsize;
+        }
+
+        void CodeGenerator::visit( BranchStmt *branchStmt ) {
                 switch ( branchStmt->get_type()) {
                   case BranchStmt::Goto:
                         if ( ! branchStmt->get_target().empty() )
-                                before << "goto " << branchStmt->get_target();
+                                output << "goto " << branchStmt->get_target();
                         else { 
                                 if ( branchStmt->get_computedTarget() != 0 ) {
-                                        before << "goto *";
+                                        output << "goto *";
                                         branchStmt->get_computedTarget()->accept( *this );
                                 } // if
@@ -542 +544 @@
                         break;
                   case BranchStmt::Break:
-                        before << "break";
+                        output << "break";
                         break;
                   case BranchStmt::Continue:
-                        before << "continue";
+                        output << "continue";
                         break;
                 }
-                before << ";";
-        }
-
-
-        void CodeGenerator2::visit( ReturnStmt *returnStmt ) {
-                before << "return ";
+                output << ";";
+        }
+
+
+        void CodeGenerator::visit( ReturnStmt *returnStmt ) {
+                output << "return ";
 
                 // xxx -- check for null expression;
@@ -559 +561 @@
                         returnStmt->get_expr()->accept( *this );
                 } // if
-                after += ";";
-        }
-
-        void CodeGenerator2::visit( WhileStmt *whileStmt ) {
+                output << ";";
+        }
+
+        void CodeGenerator::visit( WhileStmt *whileStmt ) {
                 if ( whileStmt->get_isDoWhile() )
-                        before << "do" ;
+                        output << "do" ;
                 else {
-                        before << "while (" ;
+                        output << "while (" ;
                         whileStmt->get_condition()->accept(*this );
-                        after += ")";
-                } // if
-                after += "{\n";
-                shift_left();
-
+                        output << ")";
+                } // if
+                output << " ";
+
+                output << CodeGenerator::printLabels( whileStmt->get_body()->get_labels() );
                 whileStmt->get_body()->accept( *this );
 
-                before << /* "\r" << */ string( cur_indent, ' ' ) << "}" ;
+                output << indent;
 
                 if ( whileStmt->get_isDoWhile() ) {
-                        before << " while (" ;
+                        output << " while (" ;
                         whileStmt->get_condition()->accept(*this );
-                        after += ");";
-                } // if
-
-                after += "\n";
-        }
-
-        void CodeGenerator2::visit( ForStmt *forStmt ) {
-                before << "for (";
+                        output << ");";
+                } // if
+        }
+
+        void CodeGenerator::visit( ForStmt *forStmt ) {
+                output << "for (";
 
                 if ( forStmt->get_initialization() != 0 )
                         forStmt->get_initialization()->accept( *this );
                 else
-                        before << ";";
-                shift_left();
-
+                        output << ";";
+                
                 if ( forStmt->get_condition() != 0 )
                         forStmt->get_condition()->accept( *this );
-                shift_left(); before << ";";
+                output << ";";
 
                 if ( forStmt->get_increment() != 0 )
                         forStmt->get_increment()->accept( *this );
-                shift_left(); before << ")" << endl;
+                output << ") ";
 
                 if ( forStmt->get_body() != 0 ) {
-                        cur_indent += CodeGenerator2::tabsize; 
-                        before << string( cur_indent, ' ' ) << CodeGenerator2::printLabels( forStmt->get_body()->get_labels() );
+                        output << CodeGenerator::printLabels( forStmt->get_body()->get_labels() );
                         forStmt->get_body()->accept( *this );
-                        cur_indent -= CodeGenerator2::tabsize; 
-                } // if
-        }
-
-        void CodeGenerator2::visit( NullStmt *nullStmt ) {
-                //before << /* "\r" << */ string( cur_indent, ' ' ) << CodeGenerator2::printLabels( nullStmt->get_labels() );
-                before << "/* null statement */ ;";
-        }
-
-        void CodeGenerator2::visit( DeclStmt *declStmt ) {
+                } // if
+        }
+
+        void CodeGenerator::visit( NullStmt *nullStmt ) {
+                //output << indent << CodeGenerator::printLabels( nullStmt->get_labels() );
+                output << "/* null statement */ ;";
+        }
+
+        void CodeGenerator::visit( DeclStmt *declStmt ) {
                 declStmt->get_decl()->accept( *this );
         
                 if ( doSemicolon( declStmt->get_decl() ) ) {
-                        after += ";";
-                } // if
-                shift_left();
-        }
-
-        std::string CodeGenerator2::printLabels( std::list< Label > &l ) {
+                        output << ";";
+                } // if
+        }
+
+        std::string CodeGenerator::printLabels( std::list< Label > &l ) {
                 std::string str( "" );
-                l.unique();
+                l.unique(); // assumes a sorted list. Why not use set?
 
                 for ( std::list< Label >::iterator i = l.begin(); i != l.end(); i++ )
@@ -635 +631 @@
         }
 
-        void CodeGenerator2::shift_left() {
-                before << after;
-                after = "";
-        }
-
-        void CodeGenerator2::handleStorageClass( Declaration *decl ) {
+        void CodeGenerator::handleStorageClass( Declaration *decl ) {
                 switch ( decl->get_storageClass() ) {
-                  case Declaration::NoStorageClass:
-                        break;
-                  case Declaration::Extern:
-                        before << "extern ";
-                        break;
-                  case Declaration::Static:
-                        before << "static ";
-                        break;
-                  case Declaration::Auto:
+                  case DeclarationNode::Extern:
+                        output << "extern ";
+                        break;
+                  case DeclarationNode::Static:
+                        output << "static ";
+                        break;
+                  case DeclarationNode::Auto:
                         // silently drop storage class
                         break;
-                  case Declaration::Register:
-                        before << "register ";
+                  case DeclarationNode::Register:
+                        output << "register ";
+                        break;
+                  case DeclarationNode::Inline:
+                        output << "inline ";
+                        break;
+                  case DeclarationNode::Fortran:
+                        output << "fortran ";
+                        break;
+                  case DeclarationNode::Noreturn:
+                        output << "_Noreturn ";
+                        break;
+                  case DeclarationNode::Threadlocal:
+                        output << "_Thread_local ";
+                        break;
+                  case DeclarationNode::NoStorageClass:
                         break;
                 } // switch

src/CodeGen/CodeGenerator.h

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// CodeGenerator2.h -- 
+// CodeGenerator.h -- 
 //
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Mon May 18 23:35:37 2015
-// Update Count     : 2
+// Last Modified By : Rob Schluntz
+// Last Modified On : Thu Jun 11 13:24:23 2015
+// Update Count     : 23
 //
 
@@ -17 +17 @@
 #define CODEGENV_H
 
-#include <strstream>
 #include <list>
 
@@ -25 +24 @@
 
 namespace CodeGen {
-        class CodeGenerator2 : public Visitor {
+        class CodeGenerator : public Visitor {
           public:
                 static int tabsize;
 
-                CodeGenerator2( std::ostream &os );
-                CodeGenerator2( std::ostream &os, std::string, int indent = 0, bool infun = false );
-                CodeGenerator2( std::ostream &os, char *, int indent = 0, bool infun = false );
-
-                CodeGenerator2( CodeGenerator2 & );
+                CodeGenerator( std::ostream &os );
+                CodeGenerator( std::ostream &os, std::string, int indent = 0, bool infun = false );
+                CodeGenerator( std::ostream &os, char *, int indent = 0, bool infun = false );
 
                 //*** Declaration
@@ -82 +79 @@
                 virtual void visit( DeclStmt * ); 
 
-                std::string get_string( void );
-                void add_string_left( std::string s ) { before << s; }
-                void shift_left();
                 template< class Iterator > void genCommaList( Iterator begin, Iterator end );
+
+                struct Indenter {
+                        Indenter(CodeGenerator &cg) : cg(cg) {}
+                        CodeGenerator & cg;
+                        std::ostream& operator()(std::ostream & os);
+                };
           private:
+
+                Indenter indent;
                 int cur_indent;
                 bool insideFunction;
-                std::ostream &before;
-                std::string after;
+                std::ostream &output;
 
                 static std::string printLabels ( std::list < Label > & );
@@ -100 +101 @@
         
         template< class Iterator >
-        void CodeGenerator2::genCommaList( Iterator begin, Iterator end ) {
+        void CodeGenerator::genCommaList( Iterator begin, Iterator end ) {
                 if ( begin == end ) return;
 
@@ -106 +107 @@
                         (*begin++)->accept( *this );
                         if ( begin == end ) return;
-                        before << ", ";
+                        output << ", ";
                 } // for
         }

src/CodeGen/GenType.cc

@@ -10 +10 @@
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Mon May 18 23:38:22 2015
-// Update Count     : 2
-//
-
-#include <strstream>
+// Last Modified On : Mon Jun  8 14:36:02 2015
+// Update Count     : 9
+//
+
+#include <sstream>
 #include <cassert>
 
 #include "GenType.h"
-#include "CodeGenerator2.h"
+#include "CodeGenerator.h"
 #include "SynTree/Visitor.h"
 #include "SynTree/Type.h"
@@ -68 +68 @@
 
         void GenType::genArray( const Type::Qualifiers &qualifiers, Type *base, Expression *dimension, bool isVarLen, bool isStatic ) {
-                std::ostrstream os;
+                std::ostringstream os;
                 if ( typeString != "" ) {
                         if ( typeString[ 0 ] == '*' ) {
@@ -97 +97 @@
                 } // if
                 if ( dimension != 0 ) {
-                        CodeGenerator2 cg( os );
+                        CodeGenerator cg( os );
                         dimension->accept( cg );
                 } // if
                 os << "]";
 
-                typeString = std::string( os.str(), os.pcount() );
+                typeString = os.str();
   
                 base->accept( *this );
@@ -127 +127 @@
 
         void GenType::visit( FunctionType *funcType ) {
-                std::ostrstream os;
+                std::ostringstream os;
 
                 if ( typeString != "" ) {
@@ -148 +148 @@
                         } // if
                 } else {
-                        CodeGenerator2 cg( os );
+                        CodeGenerator cg( os );
                         os << "(" ;
 
@@ -159 +159 @@
                 } // if
   
-                typeString = std::string( os.str(), os.pcount() );
+                typeString = os.str();
 
                 if ( funcType->get_returnVals().size() == 0 ) {

src/CodeGen/Generate.cc

@@ -10 +10 @@
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Mon May 18 23:39:24 2015
-// Update Count     : 1
+// Last Modified On : Thu Jun  4 14:04:25 2015
+// Update Count     : 5
 //
 
@@ -21 +21 @@
 #include "Generate.h"
 #include "SynTree/Declaration.h"
-
-#include "CodeGenerator2.h"
+#include "CodeGenerator.h"
 
 using namespace std;
@@ -28 +27 @@
 namespace CodeGen {
         void generate( std::list< Declaration* > translationUnit, std::ostream &os, bool doIntrinsics ) {
-                CodeGen::CodeGenerator2 cgv( os );
+                CodeGen::CodeGenerator cgv( os );
 
                 for ( std::list<Declaration *>::iterator i = translationUnit.begin(); i != translationUnit.end();  i++ ) {
                         if ( LinkageSpec::isGeneratable( (*i)->get_linkage() ) && (doIntrinsics || ! LinkageSpec::isBuiltin( (*i)->get_linkage() ) ) ) {
                                 (*i)->accept(cgv);
-                                cgv.shift_left();
                                 if ( doSemicolon( *i ) ) {
                                         os << ";";

src/CodeGen/OperatorTable.cc

@@ -10 +10 @@
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Mon May 18 23:42:07 2015
-// Update Count     : 2
+// Last Modified On : Tue Jun 23 17:41:14 2015
+// Update Count     : 5
 //
 
@@ -20 +20 @@
         namespace {
                 const OperatorInfo tableValues[] = {
-                        {       "?[?]",         "",             "_operator_index",                      OT_INDEX                },
-                        {       "?()",          "",             "_operator_call",                       OT_CALL                 },
-                        {       "?++",          "++",   "_operator_postincr",           OT_POSTFIXASSIGN        },
-                        {       "?--",          "--",   "_operator_postdecr",           OT_POSTFIXASSIGN        },
-                        {       "*?",           "*",    "_operator_deref",                      OT_PREFIX               },
-                        {       "+?",           "+",    "_operator_unaryplus",          OT_PREFIX               },
-                        {       "-?",           "-",    "_operator_unaryminus",         OT_PREFIX               },
-                        {       "~?",           "~",    "_operator_bitnot",                     OT_PREFIX               },
-                        {       "!?",           "!",    "_operator_lognot",                     OT_PREFIX               },
-                        {       "++?",          "++",   "_operator_preincr",            OT_PREFIXASSIGN         },
-                        {       "--?",          "--",   "_operator_predecr",            OT_PREFIXASSIGN         },
-                        {       "?*?",          "*",    "_operator_multiply",           OT_INFIX                },
-                        {       "?/?",          "/",    "_operator_divide",                     OT_INFIX                },
-                        {       "?%?",          "%",    "_operator_modulus",            OT_INFIX                },
-                        {       "?+?",          "+",    "_operator_add",                        OT_INFIX                },
-                        {       "?-?",          "-",    "_operator_subtract",           OT_INFIX                },
-                        {       "?<<?",         "<<",   "_operator_shiftleft",          OT_INFIX                },
-                        {       "?>>?",         ">>",   "_operator_shiftright",         OT_INFIX                },
-                        {       "?<?",          "<",    "_operator_less",                       OT_INFIX                },
-                        {       "?>?",          ">",    "_operator_greater",            OT_INFIX                },
-                        {       "?<=?",         "<=",   "_operator_lessequal",          OT_INFIX                },
-                        {       "?>=?",         ">=",   "_operator_greaterequal",       OT_INFIX                },
-                        {       "?==?",         "==",   "_operator_equal",                      OT_INFIX                },
-                        {       "?!=?",         "!=",   "_operator_notequal",           OT_INFIX                },
-                        {       "?&?",          "&",    "_operator_bitand",                     OT_INFIX                },
-                        {       "?^?",          "^",    "_operator_bitxor",                     OT_INFIX                },
-                        {       "?|?",          "|",    "_operator_bitor",                      OT_INFIX                },
-                        {       "?=?",          "=",    "_operator_assign",                     OT_INFIXASSIGN          },
-                        {       "?*=?",         "*=",   "_operator_multassign",         OT_INFIXASSIGN          },
-                        {       "?/=?",         "/=",   "_operator_divassign",          OT_INFIXASSIGN          },
-                        {       "?%=?",         "%=",   "_operator_modassign",          OT_INFIXASSIGN          },
-                        {       "?+=?",         "+=",   "_operator_addassign",          OT_INFIXASSIGN          },
-                        {       "?-=?",         "-=",   "_operator_subassign",          OT_INFIXASSIGN          },
+                        {       "?[?]",         "",             "_operator_index",                              OT_INDEX                        },
+                        {       "?()",          "",             "_operator_call",                               OT_CALL                         },
+                        {       "?++",          "++",   "_operator_postincr",                   OT_POSTFIXASSIGN        },
+                        {       "?--",          "--",   "_operator_postdecr",                   OT_POSTFIXASSIGN        },
+                        {       "*?",           "*",    "_operator_deref",                              OT_PREFIX                       },
+                        {       "+?",           "+",    "_operator_unaryplus",                  OT_PREFIX                       },
+                        {       "-?",           "-",    "_operator_unaryminus",                 OT_PREFIX                       },
+                        {       "~?",           "~",    "_operator_bitnot",                             OT_PREFIX                       },
+                        {       "!?",           "!",    "_operator_lognot",                             OT_PREFIX                       },
+                        {       "++?",          "++",   "_operator_preincr",                    OT_PREFIXASSIGN         },
+                        {       "--?",          "--",   "_operator_predecr",                    OT_PREFIXASSIGN         },
+                        {       "?*?",          "*",    "_operator_multiply",                   OT_INFIX                        },
+                        {       "?/?",          "/",    "_operator_divide",                             OT_INFIX                        },
+                        {       "?%?",          "%",    "_operator_modulus",                    OT_INFIX                        },
+                        {       "?+?",          "+",    "_operator_add",                                OT_INFIX                        },
+                        {       "?-?",          "-",    "_operator_subtract",                   OT_INFIX                        },
+                        {       "?<<?",         "<<",   "_operator_shiftleft",                  OT_INFIX                        },
+                        {       "?>>?",         ">>",   "_operator_shiftright",                 OT_INFIX                        },
+                        {       "?<?",          "<",    "_operator_less",                               OT_INFIX                        },
+                        {       "?>?",          ">",    "_operator_greater",                    OT_INFIX                        },
+                        {       "?<=?",         "<=",   "_operator_lessequal",                  OT_INFIX                        },
+                        {       "?>=?",         ">=",   "_operator_greaterequal",               OT_INFIX                        },
+                        {       "?==?",         "==",   "_operator_equal",                              OT_INFIX                        },
+                        {       "?!=?",         "!=",   "_operator_notequal",                   OT_INFIX                        },
+                        {       "?&?",          "&",    "_operator_bitand",                             OT_INFIX                        },
+                        {       "?^?",          "^",    "_operator_bitxor",                             OT_INFIX                        },
+                        {       "?|?",          "|",    "_operator_bitor",                              OT_INFIX                        },
+                        {       "?=?",          "=",    "_operator_assign",                             OT_INFIXASSIGN          },
+                        {       "?*=?",         "*=",   "_operator_multassign",                 OT_INFIXASSIGN          },
+                        {       "?/=?",         "/=",   "_operator_divassign",                  OT_INFIXASSIGN          },
+                        {       "?%=?",         "%=",   "_operator_modassign",                  OT_INFIXASSIGN          },
+                        {       "?+=?",         "+=",   "_operator_addassign",                  OT_INFIXASSIGN          },
+                        {       "?-=?",         "-=",   "_operator_subassign",                  OT_INFIXASSIGN          },
                         {       "?<<=?",        "<<=",  "_operator_shiftleftassign",    OT_INFIXASSIGN          },
                         {       "?>>=?",        ">>=",  "_operator_shiftrightassign",   OT_INFIXASSIGN          },
-                        {       "?&=?",         "&=",   "_operator_bitandassign",       OT_INFIXASSIGN          },
-                        {       "?^=?",         "^=",   "_operator_bitxorassign",       OT_INFIXASSIGN          },
-                        {       "?|=?",         "|=",   "_operator_bitorassign",        OT_INFIXASSIGN          },
-                        {       "0",            "0",    "_constant_zero",                       OT_CONSTANT             },
-                        {       "1",            "1",    "_constant_one",                        OT_CONSTANT             }
+                        {       "?&=?",         "&=",   "_operator_bitandassign",               OT_INFIXASSIGN          },
+                        {       "?^=?",         "^=",   "_operator_bitxorassign",               OT_INFIXASSIGN          },
+                        {       "?|=?",         "|=",   "_operator_bitorassign",                OT_INFIXASSIGN          },
+                        {       "&&",           "&&",   "&&",                                                   OT_LABELADDRESS         },
+                        {       "0",            "0",    "_constant_zero",                               OT_CONSTANT                     },
+                        {       "1",            "1",    "_constant_one",                                OT_CONSTANT                     }
                 };
 

src/CodeGen/OperatorTable.h

@@ -10 +10 @@
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Mon May 18 23:43:07 2015
-// Update Count     : 2
+// Last Modified On : Tue Jun 23 16:09:27 2015
+// Update Count     : 3
 //
 
@@ -29 +29 @@
                 OT_POSTFIXASSIGN,
                 OT_INFIXASSIGN,
+                OT_LABELADDRESS,
                 OT_CONSTANT
         };

src/CodeGen/module.mk

@@ +1 @@
+######################### -*- Mode: Makefile-Gmake -*- ########################
+##
+## Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
+##
+## The contents of this file are covered under the licence agreement in the
+## file "LICENCE" distributed with Cforall.
+##
+## module.mk -- 
+##
+## Author           : Richard C. Bilson
+## Created On       : Mon Jun  1 17:49:17 2015
+## Last Modified By : Peter A. Buhr
+## Last Modified On : Tue Jun  2 11:17:02 2015
+## Update Count     : 3
+###############################################################################
+
+#SRC +=  ArgTweak/Rewriter.cc \
+#       ArgTweak/Mutate.cc
+
 SRC +=  CodeGen/Generate.cc \
-        CodeGen/CodeGenerator2.cc \
+        CodeGen/CodeGenerator.cc \
         CodeGen/GenType.cc \
         CodeGen/FixNames.cc \
-        CodeGen/OperatorTable.cc \
-        $(NULL)
+        CodeGen/OperatorTable.cc