Changes in / [47b5b63:39fea2f]

Location:

src

Files:

• CodeGen/CodeGenerator.cc (modified) (59 diffs)
• CodeGen/CodeGenerator.h (modified) (5 diffs)
• CodeGen/GenType.cc (modified) (5 diffs)
• CodeGen/Generate.cc (modified) (6 diffs)
• CodeTools/TrackLoc.cc (modified) (3 diffs)
• Common/CodeLocation.h (modified) (4 diffs)
• Common/PassVisitor.h (modified) (2 diffs)
• Common/PassVisitor.impl.h (modified) (1 diff)
• Common/SemanticError.cc (modified) (1 diff)
• Common/SemanticError.h (modified) (1 diff)
• ControlStruct/ExceptTranslate.cc (modified) (2 diffs)
• InitTweak/FixInit.cc (modified) (9 diffs)
• Parser/ParseNode.h (modified) (2 diffs)
• Parser/lex.ll (modified) (1 diff)
• Parser/parser.yy (modified) (2 diffs)
• SymTab/Autogen.cc (modified) (1 diff)
• SynTree/BaseSyntaxNode.h (modified) (1 diff)
• tests/.expect/dtor-early-exit-ERR1.txt (modified) (1 diff)
• tests/.expect/dtor-early-exit-ERR2.txt (modified) (1 diff)

src/CodeGen/CodeGenerator.cc

@@ -79 +79 @@
         }
 
-        /* Using updateLocation at the beginning of a node and endl
+        /* Using updateLocation at the beginning of a node and nextLine
          * within a node should become the method of formating.
          */
         void CodeGenerator::updateLocation( CodeLocation const & to ) {
-                // skip if linemarks shouldn't appear or if codelocation is unset
-                if ( !lineMarks || to.isUnset() ) return;
-
-                if ( currentLocation.followedBy( to, 0 ) ) {
+                if ( !lineMarks ) {
+                        return;
+                } else if ( currentLocation.followedBy( to, 0 ) ) {
                         return;
                 } else if ( currentLocation.followedBy( to, 1 ) ) {
                         output << "\n" << indent;
-                        currentLocation.first_line += 1;
+                        currentLocation.linenumber += 1;
                 } else if ( currentLocation.followedBy( to, 2 ) ) {
                         output << "\n\n" << indent;
-                        currentLocation.first_line += 2;
-                } else {
-                        output << "\n# " << to.first_line << " \"" << to.filename
+                        currentLocation.linenumber += 2;
+                } else {
+                        output << "\n# " << to.linenumber << " \"" << to.filename
                                << "\"\n" << indent;
                         currentLocation = to;
@@ -106 +105 @@
         }
 
-        // replace endl
-        ostream & CodeGenerator::LineEnder::operator()( ostream & os ) const {
-                // if ( !cg.lineMarks ) {
-                //      os << "\n" << cg.indent << std::flush;
-                // }
-                os << "\n" << std::flush;
-                cg.currentLocation.first_line++;
-                // os << "/* did endl; current loc is: " << cg.currentLocation.first_line << "*/";
-                return os;
-        }
-
-        CodeGenerator::CodeGenerator( std::ostream & os, bool pretty, bool genC, bool lineMarks ) : indent( CodeGenerator::tabsize ), output( os ), printLabels( *this ), pretty( pretty ), genC( genC ), lineMarks( lineMarks ), endl( *this ) {}
+        void CodeGenerator::nextLine() {
+                if ( !lineMarks ) {
+                        output << "\n" << indent << std::flush;
+                }
+        }
+
+        CodeGenerator::CodeGenerator( std::ostream & os, bool pretty, bool genC, bool lineMarks ) : indent( CodeGenerator::tabsize ), insideFunction( false ), output( os ), printLabels( *this ), pretty( pretty ), genC( genC ), lineMarks( lineMarks ) {}
 
         string CodeGenerator::mangleName( DeclarationWithType * decl ) {
@@ -145 +139 @@
         } // CodeGenerator::genAttributes
 
-        // *** BaseSyntaxNode
-        void CodeGenerator::previsit( BaseSyntaxNode * node ) {
-                // turn off automatic recursion for all nodes, to allow each visitor to
-                // precisely control the order in which its children are visited.
-                visit_children = false;
-                updateLocation( node );
-        }
-
-        // *** BaseSyntaxNode
-        void CodeGenerator::postvisit( BaseSyntaxNode * node ) {
-                std::stringstream ss;
-                node->print( ss );
-                assertf( false, "Unhandled node reached in CodeGenerator: %s", ss.str().c_str() );
-        }
 
         // *** Declarations
-        void CodeGenerator::postvisit( FunctionDecl * functionDecl ) {
+        void CodeGenerator::visit( FunctionDecl * functionDecl ) {
                 extension( functionDecl );
                 genAttributes( functionDecl->get_attributes() );
@@ -172 +152 @@
                 asmName( functionDecl );
 
+                // acceptAll( functionDecl->get_oldDecls(), *this );
                 if ( functionDecl->get_statements() ) {
-                        functionDecl->get_statements()->accept( *visitor );
-                } // if
-        }
-
-        void CodeGenerator::postvisit( ObjectDecl * objectDecl ) {
+                        functionDecl->get_statements()->accept( *this );
+                } // if
+        }
+
+        void CodeGenerator::visit( ObjectDecl * objectDecl ) {
                 if (objectDecl->get_name().empty() && genC ) {
                         // only generate an anonymous name when generating C code, otherwise it clutters the output too much
@@ -194 +175 @@
                 if ( objectDecl->get_init() ) {
                         output << " = ";
-                        objectDecl->get_init()->accept( *visitor );
+                        objectDecl->get_init()->accept( *this );
                 } // if
 
                 if ( objectDecl->get_bitfieldWidth() ) {
                         output << ":";
-                        objectDecl->get_bitfieldWidth()->accept( *visitor );
+                        objectDecl->get_bitfieldWidth()->accept( *this );
                 } // if
         }
@@ -222 +203 @@
                         ++indent;
                         for ( std::list< Declaration* >::iterator i = memb.begin(); i != memb.end(); i++ ) {
+                                updateLocation( *i );
                                 output << indent;
-                                (*i)->accept( *visitor );
+                                (*i)->accept( *this );
                                 output << ";" << endl;
                         } // for
@@ -233 +215 @@
         }
 
-        void CodeGenerator::postvisit( StructDecl * structDecl ) {
+        void CodeGenerator::visit( StructDecl * structDecl ) {
                 extension( structDecl );
                 handleAggregate( structDecl, "struct " );
         }
 
-        void CodeGenerator::postvisit( UnionDecl * unionDecl ) {
+        void CodeGenerator::visit( UnionDecl * unionDecl ) {
                 extension( unionDecl );
                 handleAggregate( unionDecl, "union " );
         }
 
-        void CodeGenerator::postvisit( EnumDecl * enumDecl ) {
+        void CodeGenerator::visit( EnumDecl * enumDecl ) {
                 extension( enumDecl );
+                updateLocation( enumDecl );
                 output << "enum ";
                 genAttributes( enumDecl->get_attributes() );
@@ -259 +242 @@
                                 ObjectDecl * obj = dynamic_cast< ObjectDecl* >( *i );
                                 assert( obj );
+                                updateLocation( obj );
                                 output << indent << mangleName( obj );
                                 if ( obj->get_init() ) {
                                         output << " = ";
-                                        obj->get_init()->accept( *visitor );
+                                        obj->get_init()->accept( *this );
                                 } // if
                                 output << "," << endl;
@@ -273 +257 @@
         }
 
-        void CodeGenerator::postvisit( TraitDecl * traitDecl ) {
+        void CodeGenerator::visit( TraitDecl * traitDecl ) {
                 assertf( ! genC, "TraitDecls should not reach code generation." );
                 extension( traitDecl );
@@ -279 +263 @@
         }
 
-        void CodeGenerator::postvisit( TypedefDecl * typeDecl ) {
+        void CodeGenerator::visit( TypedefDecl * typeDecl ) {
                 assertf( ! genC, "Typedefs are removed and substituted in earlier passes." );
+                updateLocation( typeDecl );
                 output << "typedef ";
                 output << genType( typeDecl->get_base(), typeDecl->get_name(), pretty, genC ) << endl;
         }
 
-        void CodeGenerator::postvisit( TypeDecl * typeDecl ) {
+        void CodeGenerator::visit( TypeDecl * typeDecl ) {
                 assertf( ! genC, "TypeDecls should not reach code generation." );
                 output << typeDecl->genTypeString() << " " << typeDecl->get_name();
@@ -298 +283 @@
         }
 
-        void CodeGenerator::postvisit( Designation * designation ) {
+        void CodeGenerator::visit( Designation * designation ) {
                 std::list< Expression * > designators = designation->get_designators();
                 if ( designators.size() == 0 ) return;
@@ -305 +290 @@
                                 // if expression is a NameExpr or VariableExpr, then initializing aggregate member
                                 output << ".";
-                                des->accept( *visitor );
+                                des->accept( *this );
                         } else {
                                 // otherwise, it has to be a ConstantExpr or CastExpr, initializing array eleemnt
                                 output << "[";
-                                des->accept( *visitor );
+                                des->accept( *this );
                                 output << "]";
                         } // if
@@ -316 +301 @@
         }
 
-        void CodeGenerator::postvisit( SingleInit * init ) {
-                init->get_value()->accept( *visitor );
-        }
-
-        void CodeGenerator::postvisit( ListInit * init ) {
+        void CodeGenerator::visit( SingleInit * init ) {
+                init->get_value()->accept( *this );
+        }
+
+        void CodeGenerator::visit( ListInit * init ) {
                 auto initBegin = init->begin();
                 auto initEnd = init->end();
@@ -328 +313 @@
                 output << "{ ";
                 for ( ; initBegin != initEnd && desigBegin != desigEnd; ) {
-                        (*desigBegin)->accept( *visitor );
-                        (*initBegin)->accept( *visitor );
+                        (*desigBegin)->accept( *this );
+                        (*initBegin)->accept( *this );
                         ++initBegin, ++desigBegin;
                         if ( initBegin != initEnd ) {
@@ -339 +324 @@
         }
 
-        void CodeGenerator::postvisit( ConstructorInit * init ){
+        void CodeGenerator::visit( __attribute__((unused)) ConstructorInit * init ){
                 assertf( ! genC, "ConstructorInit nodes should not reach code generation." );
                 // pseudo-output for constructor/destructor pairs
-                output << "<ctorinit>{" << endl << ++indent << "ctor: ";
-                maybeAccept( init->get_ctor(), *visitor );
-                output << ", " << endl << indent << "dtor: ";
-                maybeAccept( init->get_dtor(), *visitor );
-                output << endl << --indent << "}";
-        }
-
-        void CodeGenerator::postvisit( Constant * constant ) {
+                output << "<ctorinit>{" << std::endl << ++indent << "ctor: ";
+                maybeAccept( init->get_ctor(), *this );
+                output << ", " << std::endl << indent << "dtor: ";
+                maybeAccept( init->get_dtor(), *this );
+                output << std::endl << --indent << "}";
+        }
+
+        void CodeGenerator::visit( Constant * constant ) {
                 output << constant->get_value() ;
         }
 
         // *** Expressions
-        void CodeGenerator::postvisit( ApplicationExpr * applicationExpr ) {
+        void CodeGenerator::visit( ApplicationExpr * applicationExpr ) {
                 extension( applicationExpr );
                 if ( VariableExpr * varExpr = dynamic_cast< VariableExpr* >( applicationExpr->get_function() ) ) {
@@ -363 +348 @@
                                   case OT_INDEX:
                                         assert( applicationExpr->get_args().size() == 2 );
-                                        (*arg++)->accept( *visitor );
+                                        (*arg++)->accept( *this );
                                         output << "[";
-                                        (*arg)->accept( *visitor );
+                                        (*arg)->accept( *this );
                                         output << "]";
                                         break;
@@ -380 +365 @@
                                                 // effects, so must still output this expression
                                                 output << "(";
-                                                (*arg++)->accept( *visitor );
+                                                (*arg++)->accept( *this );
                                                 output << ") /* " << opInfo.inputName << " */";
                                         } else if ( applicationExpr->get_args().size() == 2 ) {
                                                 // intrinsic two parameter constructors are essentially bitwise assignment
                                                 output << "(";
-                                                (*arg++)->accept( *visitor );
+                                                (*arg++)->accept( *this );
                                                 output << opInfo.symbol;
-                                                (*arg)->accept( *visitor );
+                                                (*arg)->accept( *this );
                                                 output << ") /* " << opInfo.inputName << " */";
                                         } else {
@@ -400 +385 @@
                                         output << "(";
                                         output << opInfo.symbol;
-                                        (*arg)->accept( *visitor );
+                                        (*arg)->accept( *this );
                                         output << ")";
                                         break;
@@ -407 +392 @@
                                   case OT_POSTFIXASSIGN:
                                         assert( applicationExpr->get_args().size() == 1 );
-                                        (*arg)->accept( *visitor );
+                                        (*arg)->accept( *this );
                                         output << opInfo.symbol;
                                         break;
@@ -416 +401 @@
                                         assert( applicationExpr->get_args().size() == 2 );
                                         output << "(";
-                                        (*arg++)->accept( *visitor );
+                                        (*arg++)->accept( *this );
                                         output << opInfo.symbol;
-                                        (*arg)->accept( *visitor );
+                                        (*arg)->accept( *this );
                                         output << ")";
                                         break;
@@ -428 +413 @@
                                 } // switch
                         } else {
-                                varExpr->accept( *visitor );
+                                varExpr->accept( *this );
                                 output << "(";
                                 genCommaList( applicationExpr->get_args().begin(), applicationExpr->get_args().end() );
@@ -434 +419 @@
                         } // if
                 } else {
-                        applicationExpr->get_function()->accept( *visitor );
+                        applicationExpr->get_function()->accept( *this );
                         output << "(";
                         genCommaList( applicationExpr->get_args().begin(), applicationExpr->get_args().end() );
@@ -441 +426 @@
         }
 
-        void CodeGenerator::postvisit( UntypedExpr * untypedExpr ) {
+        void CodeGenerator::visit( UntypedExpr * untypedExpr ) {
                 extension( untypedExpr );
                 if ( NameExpr * nameExpr = dynamic_cast< NameExpr* >( untypedExpr->get_function() ) ) {
@@ -450 +435 @@
                                   case OT_INDEX:
                                         assert( untypedExpr->get_args().size() == 2 );
-                                        (*arg++)->accept( *visitor );
+                                        (*arg++)->accept( *this );
                                         output << "[";
-                                        (*arg)->accept( *visitor );
+                                        (*arg)->accept( *this );
                                         output << "]";
                                         break;
@@ -465 +450 @@
                                                 // effects, so must still output this expression
                                                 output << "(";
-                                                (*arg++)->accept( *visitor );
+                                                (*arg++)->accept( *this );
                                                 output << ") /* " << opInfo.inputName << " */";
                                         } else if ( untypedExpr->get_args().size() == 2 ) {
                                                 // intrinsic two parameter constructors are essentially bitwise assignment
                                                 output << "(";
-                                                (*arg++)->accept( *visitor );
+                                                (*arg++)->accept( *this );
                                                 output << opInfo.symbol;
-                                                (*arg)->accept( *visitor );
+                                                (*arg)->accept( *this );
                                                 output << ") /* " << opInfo.inputName << " */";
                                         } else {
                                                 // no constructors with 0 or more than 2 parameters
-                                                assertf( ! genC, "UntypedExpr constructor/destructor with 0 or more than 2 parameters." );
-                                                output << "(";
-                                                (*arg++)->accept( *visitor );
-                                                output << opInfo.symbol << "{ ";
-                                                genCommaList( arg, untypedExpr->get_args().end() );
-                                                output << "}) /* " << opInfo.inputName << " */";
+                                                assert( false );
                                         } // if
                                         break;
@@ -491 +471 @@
                                         output << "(";
                                         output << opInfo.symbol;
-                                        (*arg)->accept( *visitor );
+                                        (*arg)->accept( *this );
                                         output << ")";
                                         break;
@@ -498 +478 @@
                                   case OT_POSTFIXASSIGN:
                                         assert( untypedExpr->get_args().size() == 1 );
-                                        (*arg)->accept( *visitor );
+                                        (*arg)->accept( *this );
                                         output << opInfo.symbol;
                                         break;
@@ -506 +486 @@
                                         assert( untypedExpr->get_args().size() == 2 );
                                         output << "(";
-                                        (*arg++)->accept( *visitor );
+                                        (*arg++)->accept( *this );
                                         output << opInfo.symbol;
-                                        (*arg)->accept( *visitor );
+                                        (*arg)->accept( *this );
                                         output << ")";
                                         break;
@@ -519 +499 @@
                                 if ( nameExpr->get_name() == "..." ) { // case V1 ... V2 or case V1~V2
                                         assert( untypedExpr->get_args().size() == 2 );
-                                        (*untypedExpr->get_args().begin())->accept( *visitor );
+                                        (*untypedExpr->get_args().begin())->accept( *this );
                                         output << " ... ";
-                                        (*--untypedExpr->get_args().end())->accept( *visitor );
+                                        (*--untypedExpr->get_args().end())->accept( *this );
                                 } else {                                                                // builtin routines
-                                        nameExpr->accept( *visitor );
+                                        nameExpr->accept( *this );
                                         output << "(";
                                         genCommaList( untypedExpr->get_args().begin(), untypedExpr->get_args().end() );
@@ -530 +510 @@
                         } // if
                 } else {
-                        untypedExpr->get_function()->accept( *visitor );
+                        untypedExpr->get_function()->accept( *this );
                         output << "(";
                         genCommaList( untypedExpr->get_args().begin(), untypedExpr->get_args().end() );
@@ -537 +517 @@
         }
 
-        void CodeGenerator::postvisit( RangeExpr * rangeExpr ) {
-                rangeExpr->get_low()->accept( *visitor );
+        void CodeGenerator::visit( RangeExpr * rangeExpr ) {
+                rangeExpr->get_low()->accept( *this );
                 output << " ... ";
-                rangeExpr->get_high()->accept( *visitor );
-        }
-
-        void CodeGenerator::postvisit( NameExpr * nameExpr ) {
+                rangeExpr->get_high()->accept( *this );
+        }
+
+        void CodeGenerator::visit( NameExpr * nameExpr ) {
                 extension( nameExpr );
                 OperatorInfo opInfo;
@@ -554 +534 @@
         }
 
-        void CodeGenerator::postvisit( AddressExpr * addressExpr ) {
+        void CodeGenerator::visit( AddressExpr * addressExpr ) {
                 extension( addressExpr );
                 output << "(&";
-                addressExpr->arg->accept( *visitor );
+                addressExpr->arg->accept( *this );
                 output << ")";
         }
 
-        void CodeGenerator::postvisit( LabelAddressExpr *addressExpr ) {
+        void CodeGenerator::visit( LabelAddressExpr *addressExpr ) {
                 extension( addressExpr );
                 output << "(&&" << addressExpr->arg << ")";
         }
 
-        void CodeGenerator::postvisit( CastExpr * castExpr ) {
+        void CodeGenerator::visit( CastExpr * castExpr ) {
                 extension( castExpr );
                 output << "(";
@@ -579 +559 @@
                         output << ")";
                 } // if
-                castExpr->get_arg()->accept( *visitor );
+                castExpr->get_arg()->accept( *this );
                 output << ")";
         }
 
-        void CodeGenerator::postvisit( VirtualCastExpr * castExpr ) {
+        void CodeGenerator::visit( VirtualCastExpr * castExpr ) {
                 assertf( ! genC, "VirtualCastExpr should not reach code generation." );
                 extension( castExpr );
                 output << "(virtual ";
-                castExpr->get_arg()->accept( *visitor );
+                castExpr->get_arg()->accept( *this );
                 output << ")";
         }
 
-        void CodeGenerator::postvisit( UntypedMemberExpr * memberExpr ) {
+        void CodeGenerator::visit( UntypedMemberExpr * memberExpr ) {
                 assertf( ! genC, "UntypedMemberExpr should not reach code generation." );
                 extension( memberExpr );
-                memberExpr->get_aggregate()->accept( *visitor );
+                memberExpr->get_aggregate()->accept( *this );
                 output << ".";
-                memberExpr->get_member()->accept( *visitor );
-        }
-
-        void CodeGenerator::postvisit( MemberExpr * memberExpr ) {
+                memberExpr->get_member()->accept( *this );
+        }
+
+        void CodeGenerator::visit( MemberExpr * memberExpr ) {
                 extension( memberExpr );
-                memberExpr->get_aggregate()->accept( *visitor );
+                memberExpr->get_aggregate()->accept( *this );
                 output << "." << mangleName( memberExpr->get_member() );
         }
 
-        void CodeGenerator::postvisit( VariableExpr * variableExpr ) {
+        void CodeGenerator::visit( VariableExpr * variableExpr ) {
                 extension( variableExpr );
                 OperatorInfo opInfo;
@@ -615 +595 @@
         }
 
-        void CodeGenerator::postvisit( ConstantExpr * constantExpr ) {
+        void CodeGenerator::visit( ConstantExpr * constantExpr ) {
                 assert( constantExpr->get_constant() );
                 extension( constantExpr );
-                constantExpr->get_constant()->accept( *visitor );
-        }
-
-        void CodeGenerator::postvisit( SizeofExpr * sizeofExpr ) {
+                constantExpr->get_constant()->accept( *this );
+        }
+
+        void CodeGenerator::visit( SizeofExpr * sizeofExpr ) {
                 extension( sizeofExpr );
                 output << "sizeof(";
@@ -627 +607 @@
                         output << genType( sizeofExpr->get_type(), "", pretty, genC );
                 } else {
-                        sizeofExpr->get_expr()->accept( *visitor );
+                        sizeofExpr->get_expr()->accept( *this );
                 } // if
                 output << ")";
         }
 
-        void CodeGenerator::postvisit( AlignofExpr * alignofExpr ) {
+        void CodeGenerator::visit( AlignofExpr * alignofExpr ) {
                 // use GCC extension to avoid bumping std to C11
                 extension( alignofExpr );
@@ -639 +619 @@
                         output << genType( alignofExpr->get_type(), "", pretty, genC );
                 } else {
-                        alignofExpr->get_expr()->accept( *visitor );
+                        alignofExpr->get_expr()->accept( *this );
                 } // if
                 output << ")";
         }
 
-        void CodeGenerator::postvisit( UntypedOffsetofExpr * offsetofExpr ) {
+        void CodeGenerator::visit( UntypedOffsetofExpr * offsetofExpr ) {
                 assertf( ! genC, "UntypedOffsetofExpr should not reach code generation." );
                 output << "offsetof(";
@@ -652 +632 @@
         }
 
-        void CodeGenerator::postvisit( OffsetofExpr * offsetofExpr ) {
+        void CodeGenerator::visit( OffsetofExpr * offsetofExpr ) {
                 // use GCC builtin
                 output << "__builtin_offsetof(";
@@ -660 +640 @@
         }
 
-        void CodeGenerator::postvisit( OffsetPackExpr * offsetPackExpr ) {
+        void CodeGenerator::visit( OffsetPackExpr * offsetPackExpr ) {
                 assertf( ! genC, "OffsetPackExpr should not reach code generation." );
                 output << "__CFA_offsetpack(" << genType( offsetPackExpr->get_type(), "", pretty, genC ) << ")";
         }
 
-        void CodeGenerator::postvisit( LogicalExpr * logicalExpr ) {
+        void CodeGenerator::visit( LogicalExpr * logicalExpr ) {
                 extension( logicalExpr );
                 output << "(";
-                logicalExpr->get_arg1()->accept( *visitor );
+                logicalExpr->get_arg1()->accept( *this );
                 if ( logicalExpr->get_isAnd() ) {
                         output << " && ";
@@ -674 +654 @@
                         output << " || ";
                 } // if
-                logicalExpr->get_arg2()->accept( *visitor );
+                logicalExpr->get_arg2()->accept( *this );
                 output << ")";
         }
 
-        void CodeGenerator::postvisit( ConditionalExpr * conditionalExpr ) {
+        void CodeGenerator::visit( ConditionalExpr * conditionalExpr ) {
                 extension( conditionalExpr );
                 output << "(";
-                conditionalExpr->get_arg1()->accept( *visitor );
+                conditionalExpr->get_arg1()->accept( *this );
                 output << " ? ";
-                conditionalExpr->get_arg2()->accept( *visitor );
+                conditionalExpr->get_arg2()->accept( *this );
                 output << " : ";
-                conditionalExpr->get_arg3()->accept( *visitor );
+                conditionalExpr->get_arg3()->accept( *this );
                 output << ")";
         }
 
-        void CodeGenerator::postvisit( CommaExpr * commaExpr ) {
+        void CodeGenerator::visit( CommaExpr * commaExpr ) {
                 extension( commaExpr );
                 output << "(";
@@ -696 +676 @@
                         commaExpr->set_arg1( new CastExpr( commaExpr->get_arg1() ) );
                 }
-                commaExpr->get_arg1()->accept( *visitor );
+                commaExpr->get_arg1()->accept( *this );
                 output << " , ";
-                commaExpr->get_arg2()->accept( *visitor );
+                commaExpr->get_arg2()->accept( *this );
                 output << ")";
         }
 
-        void CodeGenerator::postvisit( TupleAssignExpr * tupleExpr ) {
+        void CodeGenerator::visit( TupleAssignExpr * tupleExpr ) {
                 assertf( ! genC, "TupleAssignExpr should not reach code generation." );
-                tupleExpr->stmtExpr->accept( *visitor );
-        }
-
-        void CodeGenerator::postvisit( UntypedTupleExpr * tupleExpr ) {
+                tupleExpr->stmtExpr->accept( *this );
+        }
+
+        void CodeGenerator::visit( UntypedTupleExpr * tupleExpr ) {
                 assertf( ! genC, "UntypedTupleExpr should not reach code generation." );
                 extension( tupleExpr );
@@ -715 +695 @@
         }
 
-        void CodeGenerator::postvisit( TupleExpr * tupleExpr ) {
+        void CodeGenerator::visit( TupleExpr * tupleExpr ) {
                 assertf( ! genC, "TupleExpr should not reach code generation." );
                 extension( tupleExpr );
@@ -723 +703 @@
         }
 
-        void CodeGenerator::postvisit( TupleIndexExpr * tupleExpr ) {
+        void CodeGenerator::visit( TupleIndexExpr * tupleExpr ) {
                 assertf( ! genC, "TupleIndexExpr should not reach code generation." );
                 extension( tupleExpr );
-                tupleExpr->get_tuple()->accept( *visitor );
+                tupleExpr->get_tuple()->accept( *this );
                 output << "." << tupleExpr->get_index();
         }
 
-        void CodeGenerator::postvisit( TypeExpr * typeExpr ) {
+        void CodeGenerator::visit( TypeExpr * typeExpr ) {
                 // if ( genC ) std::cerr << "typeexpr still exists: " << typeExpr << std::endl;
                 // assertf( ! genC, "TypeExpr should not reach code generation." );
@@ -738 +718 @@
         }
 
-        void CodeGenerator::postvisit( AsmExpr * asmExpr ) {
+        void CodeGenerator::visit( AsmExpr * asmExpr ) {
                 if ( asmExpr->get_inout() ) {
                         output << "[ ";
-                        asmExpr->get_inout()->accept( *visitor );
+                        asmExpr->get_inout()->accept( *this );
                         output << " ] ";
                 } // if
-                asmExpr->get_constraint()->accept( *visitor );
+                asmExpr->get_constraint()->accept( *this );
                 output << " ( ";
-                asmExpr->get_operand()->accept( *visitor );
+                asmExpr->get_operand()->accept( *this );
                 output << " )";
         }
 
-        void CodeGenerator::postvisit( CompoundLiteralExpr *compLitExpr ) {
+        void CodeGenerator::visit( CompoundLiteralExpr *compLitExpr ) {
                 assert( compLitExpr->get_result() && dynamic_cast< ListInit * > ( compLitExpr->get_initializer() ) );
                 output << "(" << genType( compLitExpr->get_result(), "", pretty, genC ) << ")";
-                compLitExpr->get_initializer()->accept( *visitor );
-        }
-
-        void CodeGenerator::postvisit( UniqueExpr * unqExpr ) {
+                compLitExpr->get_initializer()->accept( *this );
+        }
+
+        void CodeGenerator::visit( UniqueExpr * unqExpr ) {
                 assertf( ! genC, "Unique expressions should not reach code generation." );
                 output << "unq<" << unqExpr->get_id() << ">{ ";
-                unqExpr->get_expr()->accept( *visitor );
+                unqExpr->get_expr()->accept( *this );
                 output << " }";
         }
 
-        void CodeGenerator::postvisit( StmtExpr * stmtExpr ) {
+        void CodeGenerator::visit( StmtExpr * stmtExpr ) {
                 std::list< Statement * > & stmts = stmtExpr->get_statements()->get_kids();
-                output << "({" << endl;
+                updateLocation( stmtExpr );
+                output << "({" << std::endl;
                 ++indent;
                 unsigned int numStmts = stmts.size();
                 unsigned int i = 0;
                 for ( Statement * stmt : stmts ) {
+                        updateLocation( stmt );
                         output << indent << printLabels( stmt->get_labels() );
                         if ( i+1 == numStmts ) {
@@ -775 +757 @@
                                 // cannot cast to void, otherwise the expression statement has no value
                                 if ( ExprStmt * exprStmt = dynamic_cast< ExprStmt * >( stmt ) ) {
-                                        exprStmt->get_expr()->accept( *visitor );
+                                        exprStmt->get_expr()->accept( *this );
                                         output << ";" << endl;
                                         ++i;
@@ -781 +763 @@
                                 }
                         }
-                        stmt->accept( *visitor );
+                        stmt->accept( *this );
                         output << endl;
                         if ( wantSpacing( stmt ) ) {
@@ -792 +774 @@
         }
 
-        void CodeGenerator::postvisit( ConstructorExpr * expr ) {
-                assertf( ! genC, "Unique expressions should not reach code generation." );
-                expr->callExpr->accept( *visitor );
-        }
-
         // *** Statements
-        void CodeGenerator::postvisit( CompoundStmt * compoundStmt ) {
+        void CodeGenerator::visit( CompoundStmt * compoundStmt ) {
                 std::list<Statement*> ks = compoundStmt->get_kids();
                 output << "{" << endl;
@@ -806 +783 @@
                 for ( std::list<Statement *>::iterator i = ks.begin(); i != ks.end();  i++ ) {
                         output << indent << printLabels( (*i)->get_labels() );
-                        (*i)->accept( *visitor );
+                        (*i)->accept( *this );
 
                         output << endl;
@@ -818 +795 @@
         }
 
-        void CodeGenerator::postvisit( ExprStmt * exprStmt ) {
+        void CodeGenerator::visit( ExprStmt * exprStmt ) {
                 assert( exprStmt );
                 if ( genC ) {
@@ -824 +801 @@
                         exprStmt->set_expr( new CastExpr( exprStmt->get_expr() ) );
                 }
-                exprStmt->get_expr()->accept( *visitor );
+                exprStmt->get_expr()->accept( *this );
                 output << ";";
         }
 
-        void CodeGenerator::postvisit( AsmStmt * asmStmt ) {
+        void CodeGenerator::visit( AsmStmt * asmStmt ) {
                 output << "asm ";
                 if ( asmStmt->get_voltile() ) output << "volatile ";
                 if ( ! asmStmt->get_gotolabels().empty()  ) output << "goto ";
                 output << "( ";
-                if ( asmStmt->get_instruction() ) asmStmt->get_instruction()->accept( *visitor );
+                if ( asmStmt->get_instruction() ) asmStmt->get_instruction()->accept( *this );
                 output << " : ";
                 genCommaList( asmStmt->get_output().begin(), asmStmt->get_output().end() );
@@ -851 +828 @@
         }
 
-        void CodeGenerator::postvisit( AsmDecl * asmDecl ) {
+        void CodeGenerator::visit( AsmDecl * asmDecl ) {
                 output << "asm ";
                 AsmStmt * asmStmt = asmDecl->get_stmt();
                 output << "( ";
-                if ( asmStmt->get_instruction() ) asmStmt->get_instruction()->accept( *visitor );
+                if ( asmStmt->get_instruction() ) asmStmt->get_instruction()->accept( *this );
                 output << " )" ;
         }
 
-        void CodeGenerator::postvisit( IfStmt * ifStmt ) {
+        void CodeGenerator::visit( IfStmt * ifStmt ) {
+                updateLocation( ifStmt );
                 output << "if ( ";
-                ifStmt->get_condition()->accept( *visitor );
+                ifStmt->get_condition()->accept( *this );
                 output << " ) ";
 
-                ifStmt->get_thenPart()->accept( *visitor );
+                ifStmt->get_thenPart()->accept( *this );
 
                 if ( ifStmt->get_elsePart() != 0) {
                         output << " else ";
-                        ifStmt->get_elsePart()->accept( *visitor );
-                } // if
-        }
-
-        void CodeGenerator::postvisit( SwitchStmt * switchStmt ) {
+                        ifStmt->get_elsePart()->accept( *this );
+                } // if
+        }
+
+        void CodeGenerator::visit( SwitchStmt * switchStmt ) {
+                updateLocation( switchStmt );
                 output << "switch ( " ;
-                switchStmt->get_condition()->accept( *visitor );
+                switchStmt->get_condition()->accept( *this );
                 output << " ) ";
 
-                output << "{" << endl;
+                output << "{" << std::endl;
                 ++indent;
-                acceptAll( switchStmt->get_statements(), *visitor );
+                acceptAll( switchStmt->get_statements(), *this );
                 --indent;
                 output << indent << "}";
         }
 
-        void CodeGenerator::postvisit( CaseStmt * caseStmt ) {
+        void CodeGenerator::visit( CaseStmt * caseStmt ) {
+                updateLocation( caseStmt );
                 if ( caseStmt->isDefault()) {
                         output << "default";
                 } else {
                         output << "case ";
-                        caseStmt->get_condition()->accept( *visitor );
-                } // if
-                output << ":" << endl;
+                        caseStmt->get_condition()->accept( *this );
+                } // if
+                output << ":\n";
 
                 std::list<Statement *> sts = caseStmt->get_statements();
@@ -898 +878 @@
                 for ( std::list<Statement *>::iterator i = sts.begin(); i != sts.end();  i++) {
                         output << indent << printLabels( (*i)->get_labels() )  ;
-                        (*i)->accept( *visitor );
+                        (*i)->accept( *this );
                         output << endl;
                 } // for
@@ -904 +884 @@
         }
 
-        void CodeGenerator::postvisit( BranchStmt * branchStmt ) {
+        void CodeGenerator::visit( BranchStmt * branchStmt ) {
                 switch ( branchStmt->get_type()) {
                   case BranchStmt::Goto:
@@ -912 +892 @@
                                 if ( branchStmt->get_computedTarget() != 0 ) {
                                         output << "goto *";
-                                        branchStmt->get_computedTarget()->accept( *visitor );
+                                        branchStmt->get_computedTarget()->accept( *this );
                                 } // if
                         } // if
@@ -926 +906 @@
         }
 
-        void CodeGenerator::postvisit( ReturnStmt * returnStmt ) {
+        void CodeGenerator::visit( ReturnStmt * returnStmt ) {
                 output << "return ";
-                maybeAccept( returnStmt->get_expr(), *visitor );
+                maybeAccept( returnStmt->get_expr(), *this );
                 output << ";";
         }
 
-        void CodeGenerator::postvisit( ThrowStmt * throwStmt ) {
+        void CodeGenerator::visit( ThrowStmt * throwStmt ) {
                 assertf( ! genC, "Throw statements should not reach code generation." );
 
@@ -939 +919 @@
                 if (throwStmt->get_expr()) {
                         output << " ";
-                        throwStmt->get_expr()->accept( *visitor );
+                        throwStmt->get_expr()->accept( *this );
                 }
                 if (throwStmt->get_target()) {
                         output << " _At ";
-                        throwStmt->get_target()->accept( *visitor );
+                        throwStmt->get_target()->accept( *this );
                 }
                 output << ";";
         }
 
-        void CodeGenerator::postvisit( WhileStmt * whileStmt ) {
+        void CodeGenerator::visit( WhileStmt * whileStmt ) {
                 if ( whileStmt->get_isDoWhile() ) {
                         output << "do" ;
                 } else {
                         output << "while (" ;
-                        whileStmt->get_condition()->accept( *visitor );
+                        whileStmt->get_condition()->accept( *this );
                         output << ")";
                 } // if
@@ -959 +939 @@
 
                 output << CodeGenerator::printLabels( whileStmt->get_body()->get_labels() );
-                whileStmt->get_body()->accept( *visitor );
+                whileStmt->get_body()->accept( *this );
 
                 output << indent;
@@ -965 +945 @@
                 if ( whileStmt->get_isDoWhile() ) {
                         output << " while (" ;
-                        whileStmt->get_condition()->accept( *visitor );
+                        whileStmt->get_condition()->accept( *this );
                         output << ");";
                 } // if
         }
 
-        void CodeGenerator::postvisit( ForStmt * forStmt ) {
+        void CodeGenerator::visit( ForStmt * forStmt ) {
                 // initialization is always hoisted, so don't bother doing anything with that
                 output << "for (;";
 
                 if ( forStmt->get_condition() != 0 ) {
-                        forStmt->get_condition()->accept( *visitor );
+                        forStmt->get_condition()->accept( *this );
                 } // if
                 output << ";";
@@ -982 +962 @@
                         // cast the top-level expression to void to reduce gcc warnings.
                         Expression * expr = new CastExpr( forStmt->get_increment() );
-                        expr->accept( *visitor );
+                        expr->accept( *this );
                 } // if
                 output << ") ";
@@ -988 +968 @@
                 if ( forStmt->get_body() != 0 ) {
                         output << CodeGenerator::printLabels( forStmt->get_body()->get_labels() );
-                        forStmt->get_body()->accept( *visitor );
-                } // if
-        }
-
-        void CodeGenerator::postvisit( __attribute__((unused)) NullStmt * nullStmt ) {
+                        forStmt->get_body()->accept( *this );
+                } // if
+        }
+
+        void CodeGenerator::visit( __attribute__((unused)) NullStmt * nullStmt ) {
                 //output << indent << CodeGenerator::printLabels( nullStmt->get_labels() );
                 output << "/* null statement */ ;";
         }
 
-        void CodeGenerator::postvisit( DeclStmt * declStmt ) {
-                declStmt->get_decl()->accept( *visitor );
+        void CodeGenerator::visit( DeclStmt * declStmt ) {
+                declStmt->get_decl()->accept( *this );
 
                 if ( doSemicolon( declStmt->get_decl() ) ) {
                         output << ";";
                 } // if
-        }
-
-        void CodeGenerator::postvisit( ImplicitCtorDtorStmt * stmt ) {
-                assertf( ! genC, "ImplicitCtorDtorStmts should not reach code generation." );
-                stmt->callStmt->accept( *visitor );
         }
 

src/CodeGen/CodeGenerator.h

@@ -21 +21 @@
 
 #include "Common/Indenter.h"      // for Indenter
-#include "Common/PassVisitor.h"   // for PassVisitor
 #include "SynTree/Declaration.h"  // for DeclarationWithType (ptr only), Fun...
 #include "SynTree/Visitor.h"      // for Visitor
@@ -27 +26 @@
 
 namespace CodeGen {
-        struct CodeGenerator : public WithShortCircuiting, public WithVisitorRef<CodeGenerator> {
-          static int tabsize;
+        class CodeGenerator : public Visitor {
+          public:
+                static int tabsize;
 
                 CodeGenerator( std::ostream &os, bool pretty = false, bool genC = false, bool lineMarks = false );
-
-                //*** Turn off visit_children for all nodes
-                void previsit( BaseSyntaxNode * );
-
-                //*** Error for unhandled node types
-                void postvisit( BaseSyntaxNode * );
+                CodeGenerator( std::ostream &os, std::string, int indent = 0, bool infun = false );
+                CodeGenerator( std::ostream &os, char *, int indent = 0, bool infun = false );
 
                 //*** Declaration
-                void postvisit( StructDecl * );
-                void postvisit( FunctionDecl * );
-                void postvisit( ObjectDecl * );
-                void postvisit( UnionDecl *aggregateDecl );
-                void postvisit( EnumDecl *aggregateDecl );
-                void postvisit( TraitDecl *aggregateDecl );
-                void postvisit( TypedefDecl *typeDecl );
-                void postvisit( TypeDecl *typeDecl );
+                virtual void visit( StructDecl * );
+                virtual void visit( FunctionDecl * );
+                virtual void visit( ObjectDecl * );
+                virtual void visit( UnionDecl *aggregateDecl );
+                virtual void visit( EnumDecl *aggregateDecl );
+                virtual void visit( TraitDecl *aggregateDecl );
+                virtual void visit( TypedefDecl *typeDecl );
+                virtual void visit( TypeDecl *typeDecl );
 
                 //*** Initializer
-                void postvisit( Designation * );
-                void postvisit( SingleInit * );
-                void postvisit( ListInit * );
-                void postvisit( ConstructorInit * );
+                virtual void visit( Designation * );
+                virtual void visit( SingleInit * );
+                virtual void visit( ListInit * );
+                virtual void visit( ConstructorInit * );
 
                 //*** Constant
-                void postvisit( Constant * );
+                virtual void visit( Constant * );
 
                 //*** Expression
-                void postvisit( ApplicationExpr *applicationExpr );
-                void postvisit( UntypedExpr *untypedExpr );
-                void postvisit( RangeExpr * rangeExpr );
-                void postvisit( NameExpr *nameExpr );
-                void postvisit( AddressExpr *addressExpr );
-                void postvisit( LabelAddressExpr *addressExpr );
-                void postvisit( CastExpr *castExpr );
-                void postvisit( VirtualCastExpr *castExpr );
-                void postvisit( UntypedMemberExpr *memberExpr );
-                void postvisit( MemberExpr *memberExpr );
-                void postvisit( VariableExpr *variableExpr );
-                void postvisit( ConstantExpr *constantExpr );
-                void postvisit( SizeofExpr *sizeofExpr );
-                void postvisit( AlignofExpr *alignofExpr );
-                void postvisit( UntypedOffsetofExpr *offsetofExpr );
-                void postvisit( OffsetofExpr *offsetofExpr );
-                void postvisit( OffsetPackExpr *offsetPackExpr );
-                void postvisit( LogicalExpr *logicalExpr );
-                void postvisit( ConditionalExpr *conditionalExpr );
-                void postvisit( CommaExpr *commaExpr );
-                void postvisit( CompoundLiteralExpr *compLitExpr );
-                void postvisit( UniqueExpr * );
-                void postvisit( TupleAssignExpr * tupleExpr );
-                void postvisit( UntypedTupleExpr *tupleExpr );
-                void postvisit( TupleExpr *tupleExpr );
-                void postvisit( TupleIndexExpr * tupleExpr );
-                void postvisit( TypeExpr *typeExpr );
-                void postvisit( AsmExpr * );
-                void postvisit( StmtExpr * );
-                void postvisit( ConstructorExpr * );
+                virtual void visit( ApplicationExpr *applicationExpr );
+                virtual void visit( UntypedExpr *untypedExpr );
+                virtual void visit( RangeExpr * rangeExpr );
+                virtual void visit( NameExpr *nameExpr );
+                virtual void visit( AddressExpr *addressExpr );
+                virtual void visit( LabelAddressExpr *addressExpr );
+                virtual void visit( CastExpr *castExpr );
+                virtual void visit( VirtualCastExpr *castExpr );
+                virtual void visit( UntypedMemberExpr *memberExpr );
+                virtual void visit( MemberExpr *memberExpr );
+                virtual void visit( VariableExpr *variableExpr );
+                virtual void visit( ConstantExpr *constantExpr );
+                virtual void visit( SizeofExpr *sizeofExpr );
+                virtual void visit( AlignofExpr *alignofExpr );
+                virtual void visit( UntypedOffsetofExpr *offsetofExpr );
+                virtual void visit( OffsetofExpr *offsetofExpr );
+                virtual void visit( OffsetPackExpr *offsetPackExpr );
+                virtual void visit( LogicalExpr *logicalExpr );
+                virtual void visit( ConditionalExpr *conditionalExpr );
+                virtual void visit( CommaExpr *commaExpr );
+                virtual void visit( CompoundLiteralExpr *compLitExpr );
+                virtual void visit( UniqueExpr * );
+                virtual void visit( TupleAssignExpr * tupleExpr );
+                virtual void visit( UntypedTupleExpr *tupleExpr );
+                virtual void visit( TupleExpr *tupleExpr );
+                virtual void visit( TupleIndexExpr * tupleExpr );
+                virtual void visit( TypeExpr *typeExpr );
+                virtual void visit( AsmExpr * );
+                virtual void visit( StmtExpr * );
 
                 //*** Statements
-                void postvisit( CompoundStmt * );
-                void postvisit( ExprStmt * );
-                void postvisit( AsmStmt * );
-                void postvisit( AsmDecl * );                            // special: statement in declaration context
-                void postvisit( IfStmt * );
-                void postvisit( SwitchStmt * );
-                void postvisit( CaseStmt * );
-                void postvisit( BranchStmt * );
-                void postvisit( ReturnStmt * );
-                void postvisit( ThrowStmt * );
-                void postvisit( WhileStmt * );
-                void postvisit( ForStmt * );
-                void postvisit( NullStmt * );
-                void postvisit( DeclStmt * );
-                void postvisit( ImplicitCtorDtorStmt * );
+                virtual void visit( CompoundStmt * );
+                virtual void visit( ExprStmt * );
+                virtual void visit( AsmStmt * );
+                virtual void visit( AsmDecl * );                                // special: statement in declaration context
+                virtual void visit( IfStmt * );
+                virtual void visit( SwitchStmt * );
+                virtual void visit( CaseStmt * );
+                virtual void visit( BranchStmt * );
+                virtual void visit( ReturnStmt * );
+                virtual void visit( ThrowStmt * );
+                virtual void visit( WhileStmt * );
+                virtual void visit( ForStmt * );
+                virtual void visit( NullStmt * );
+                virtual void visit( DeclStmt * );
 
                 void genAttributes( std::list< Attribute * > & attributes );
@@ -123 +117 @@
 
                 void updateLocation( BaseSyntaxNode const * to );
-                struct LineEnder {
-                        CodeGenerator & cg;
-                        LineEnder( CodeGenerator & cg ) : cg( cg ) {}
-                        std::ostream & operator()(std::ostream &) const;
-                };
           private:
                 Indenter indent;
-                std::ostream & output;
+                bool insideFunction;
+                std::ostream &output;
                 LabelPrinter printLabels;
                 bool pretty = false;  // pretty print
                 bool genC = false;    // true if output has to be C code
                 bool lineMarks = false;
-        public:
-                LineEnder endl;
-        private:
 
                 CodeLocation currentLocation;
                 void updateLocation( CodeLocation const & to );
+                void nextLine();
 
                 void handleStorageClass( DeclarationWithType *decl );
@@ -152 +140 @@
           if ( begin == end ) return;
                 for ( ;; ) {
-                        (*begin++)->accept( *visitor );
+                        (*begin++)->accept( *this );
                   if ( begin == end ) break;
                         output << ", ";                                                         // separator
@@ -167 +155 @@
         /// returns C-compatible name of declaration
         std::string genName( DeclarationWithType * decl );
-
-        inline std::ostream & operator<<( std::ostream & os, const CodeGenerator::LineEnder & endl ) {
-                return endl( os );
-        }
 } // namespace CodeGen
 

src/CodeGen/GenType.cc

@@ -63 +63 @@
 
                 if ( ! type->get_attributes().empty() ) {
-                        PassVisitor<CodeGenerator> cg( os, pretty, genC, lineMarks );
-                        cg.pass.genAttributes( type->get_attributes() );
+                        CodeGenerator cg( os, pretty, genC, lineMarks );
+                        cg.genAttributes( type->get_attributes() );
                 } // if
 
@@ -116 +116 @@
                 } // if
                 if ( dimension != 0 ) {
-                        PassVisitor<CodeGenerator> cg( os, pretty, genC, lineMarks );
+                        CodeGenerator cg( os, pretty, genC, lineMarks );
                         dimension->accept( cg );
                 } else if ( isVarLen ) {
@@ -178 +178 @@
                         } // if
                 } else {
-                        PassVisitor<CodeGenerator> cg( os, pretty, genC, lineMarks );
+                        CodeGenerator cg( os, pretty, genC, lineMarks );
                         os << "(" ;
 
-                        cg.pass.genCommaList( pars.begin(), pars.end() );
+                        cg.genCommaList( pars.begin(), pars.end() );
 
                         if ( funcType->get_isVarArgs() ) {
@@ -201 +201 @@
                         // assertf( ! genC, "Aggregate type parameters should not reach code generation." );
                         std::ostringstream os;
-                        PassVisitor<CodeGenerator> cg( os, pretty, genC, lineMarks );
+                        CodeGenerator cg( os, pretty, genC, lineMarks );
                         os << "forall(";
-                        cg.pass.genCommaList( funcType->get_forall().begin(), funcType->get_forall().end() );
+                        cg.genCommaList( funcType->get_forall().begin(), funcType->get_forall().end() );
                         os << ")" << std::endl;
                         typeString = os.str() + typeString;
@@ -212 +212 @@
                 if ( ! refType->get_parameters().empty() ) {
                         std::ostringstream os;
-                        PassVisitor<CodeGenerator> cg( os, pretty, genC, lineMarks );
+                        CodeGenerator cg( os, pretty, genC, lineMarks );
                         os << "(";
-                        cg.pass.genCommaList( refType->get_parameters().begin(), refType->get_parameters().end() );
+                        cg.genCommaList( refType->get_parameters().begin(), refType->get_parameters().end() );
                         os << ") ";
                         return os.str();

src/CodeGen/Generate.cc

@@ -33 +33 @@
                 /// Removes misc. nodes that should not exist in CodeGen
                 struct TreeCleaner {
-                        void premutate( CompoundStmt * stmt );
-                        Statement * postmutate( ImplicitCtorDtorStmt * stmt );
+                        void previsit( CompoundStmt * stmt );
 
                         static bool shouldClean( Declaration * );
@@ -42 +41 @@
                         PassVisitor<TreeCleaner> cleaner;
                         filter( translationUnit, [](Declaration * decl) { return TreeCleaner::shouldClean(decl); }, false );
-                        mutateAll( translationUnit, cleaner );
+                        acceptAll( translationUnit, cleaner );
                 } // cleanTree
         } // namespace
@@ -49 +48 @@
                 cleanTree( translationUnit );
 
-                PassVisitor<CodeGenerator> cgv( os, pretty, generateC, lineMarks );
+                CodeGen::CodeGenerator cgv( os, pretty, generateC, lineMarks );
                 for ( auto & dcl : translationUnit ) {
                         if ( LinkageSpec::isGeneratable( dcl->get_linkage() ) && (doIntrinsics || ! LinkageSpec::isBuiltin( dcl->get_linkage() ) ) ) {
-                                cgv.pass.updateLocation( dcl );
+                                cgv.updateLocation( dcl );
                                 dcl->accept(cgv);
                                 if ( doSemicolon( dcl ) ) {
                                         os << ";";
                                 } // if
-                                os << cgv.pass.endl;
+                                os << std::endl;
                         } // if
                 } // for
@@ -66 +65 @@
                         os << CodeGen::genPrettyType( type, "" );
                 } else {
-                        PassVisitor<CodeGenerator> cgv( os, true, false, false );
+                        CodeGen::CodeGenerator cgv( os, true, false, false );
                         node->accept( cgv );
                 }
@@ -73 +72 @@
 
         namespace {
-                void TreeCleaner::premutate( CompoundStmt * cstmt ) {
+                void TreeCleaner::previsit( CompoundStmt * cstmt ) {
                         filter( cstmt->kids, [](Statement * stmt) {
                                 if ( DeclStmt * declStmt = dynamic_cast< DeclStmt * >( stmt ) ) {
@@ -80 +79 @@
                                 return false;
                         }, false );
-                }
-
-                Statement * TreeCleaner::postmutate( ImplicitCtorDtorStmt * stmt ) {
-                        Statement * callStmt = nullptr;
-                        std::swap( stmt->callStmt, callStmt );
-                        delete stmt;
-                        return callStmt;
                 }
 

src/CodeTools/TrackLoc.cc

@@ -33 +33 @@
 
 namespace CodeTools {
+
+        std::ostream & operator<<(std::ostream & out, CodeLocation const & loc) {
+                return out << loc.filename << '[' << loc.linenumber << ']';
+        }
+
         class LocationPrinter {
                 size_t printLevel;
@@ -64 +69 @@
                                 }
                                 else {
-                                        assertf( false, "Top level node has no CodeLocation %s", name.c_str() );
+                                        std::cerr << "Top level node has no CodeLocation " << name << std::endl;
+                                        exit(EXIT_FAILURE);
                                 }
                         }
@@ -89 +95 @@
                 acceptAll( translationUnit, printer );
         }
+
 } // namespace CodeTools
 

src/Common/CodeLocation.h

@@ -16 +16 @@
 #pragma once
 
-#include <iostream>
 #include <string>
 
 struct CodeLocation {
-        int first_line = -1, first_column = -1, last_line = -1, last_column = -1;
-        std::string filename = "";
+        int linenumber;
+        std::string filename;
 
         /// Create a new unset CodeLocation.
-        CodeLocation() = default;
+                CodeLocation()
+                : linenumber( -1 )
+                , filename("")
+        {}
 
         /// Create a new CodeLocation with the given values.
         CodeLocation( const char* filename, int lineno )
-                : first_line( lineno )
+                : linenumber( lineno )
                 , filename(filename ? filename : "")
         {}
@@ -35 +37 @@
 
         bool isSet () const {
-                return -1 != first_line;
+                return -1 != linenumber;
         }
 
@@ -42 +44 @@
         }
 
+        void unset () {
+                linenumber = -1;
+                filename = "";
+        }
+
+        // Use field access for set.
+
         bool followedBy( CodeLocation const & other, int seperation ) {
-                return (first_line + seperation == other.first_line &&
+                return (linenumber + seperation == other.linenumber &&
                         filename == other.filename);
         }
@@ -56 +65 @@
 };
 
-inline std::ostream & operator<<( std::ostream & out, const CodeLocation & location ) {
-        // Column number ":1" allows IDEs to parse the error message and position the cursor in the source text.
-        return location.isSet() ? out << location.filename << ":" << location.first_line << ":1 " : out;
+inline std::string to_string( const CodeLocation& location ) {
+    // Column number ":1" allows IDEs to parse the error message and position the cursor in the source text.
+    return location.isSet() ? location.filename + ":" + std::to_string(location.linenumber) + ":1 " : "";
 }
+

src/Common/PassVisitor.h

@@ -133 +133 @@
         virtual void visit( OneType *oneType ) override final;
 
-        virtual void visit( Designation *designation ) override final;
         virtual void visit( SingleInit *singleInit ) override final;
         virtual void visit( ListInit *listInit ) override final;
@@ -222 +221 @@
         virtual Type* mutate( OneType *oneType ) override final;
 
-        virtual Designation* mutate( Designation *designation ) override final;
         virtual Initializer* mutate( SingleInit *singleInit ) override final;
         virtual Initializer* mutate( ListInit *listInit ) override final;

src/Common/PassVisitor.impl.h

@@ -1926 +1926 @@
 }
 
-template< typename pass_type >
-void PassVisitor< pass_type >::visit( Designation * node ) {
-        VISIT_START( node );
-
-        maybeAccept( node->get_designators(), *this );
-
-        VISIT_END( node );
-}
-
-template< typename pass_type >
-Designation * PassVisitor< pass_type >::mutate( Designation * node ) {
-        MUTATE_START( node );
-
-        maybeMutateRef( node->get_designators(), *this );
-
-        MUTATE_END( Designation, node );
-}
-
 //--------------------------------------------------------------------------
 // SingleInit

src/Common/SemanticError.cc

@@ -45 +45 @@
         using std::to_string;
         for( auto err : errors ) {
-                os << err.location << err.description << std::endl;
+                os << to_string( err.location ) << err.description << std::endl;
         }
 }

src/Common/SemanticError.h

@@ -32 +32 @@
 
         void maybeSet( const CodeLocation & location ) {
-                if( this->location.isUnset() ) {
+                if( this->location.linenumber < 0 ) {
                         this->location = location;
                 }

src/ControlStruct/ExceptTranslate.cc

@@ -622 +622 @@
                                 assertf(false, "Invalid throw in %s at %i\n",
                                         throwStmt->location.filename.c_str(),
-                                        throwStmt->location.first_line);
+                                        throwStmt->location.linenumber);
                                 return nullptr;
                         }
@@ -633 +633 @@
                                 assertf(false, "Invalid throwResume in %s at %i\n",
                                         throwStmt->location.filename.c_str(),
-                                        throwStmt->location.first_line);
+                                        throwStmt->location.linenumber);
                                 return nullptr;
                         }

src/InitTweak/FixInit.cc

@@ -105 +105 @@
 
                 /// collects constructed object decls - used as a base class
-                struct ObjDeclCollector : public WithGuards, public WithShortCircuiting {
+                class ObjDeclCollector : public AddStmtVisitor {
+                  public:
+                        typedef AddStmtVisitor Parent;
+                        using Parent::visit;
                         // use ordered data structure to maintain ordering for set_difference and for consistent error messages
                         typedef std::list< ObjectDecl * > ObjectSet;
-                        void previsit( CompoundStmt *compoundStmt );
-                        void previsit( DeclStmt *stmt );
+                        virtual void visit( CompoundStmt *compoundStmt ) override;
+                        virtual void visit( DeclStmt *stmt ) override;
 
                         // don't go into other functions
-                        void previsit( FunctionDecl * ) { visit_children = false; }
+                        virtual void visit( FunctionDecl * ) override {}
 
                   protected:
@@ -136 +139 @@
                 }
 
-                struct LabelFinder final : public ObjDeclCollector {
+                class LabelFinder final : public ObjDeclCollector {
+                  public:
+                        typedef ObjDeclCollector Parent;
                         typedef std::map< Label, ObjectSet > LabelMap;
                         // map of Label -> live variables at that label
                         LabelMap vars;
 
-                        typedef ObjDeclCollector Parent;
-                        using Parent::previsit;
-                        void previsit( Statement * stmt );
-
-                        void previsit( CompoundStmt *compoundStmt );
-                        void previsit( DeclStmt *stmt );
+                        void handleStmt( Statement * stmt );
+
+                        // xxx - This needs to be done better.
+                        // allow some generalization among different kinds of nodes with with similar parentage (e.g. all
+                        // expressions, all statements, etc.)  important to have this to provide a single entry point so that as new
+                        // subclasses are added, there is only one place that the code has to be updated, rather than ensure that
+                        // every specialized class knows about every new kind of statement that might be added.
+                        using Parent::visit;
+                        virtual void visit( CompoundStmt *stmt ) override { handleStmt( stmt ); return Parent::visit( stmt ); }
+                        virtual void visit( ExprStmt *stmt ) override { handleStmt( stmt ); return Parent::visit( stmt ); }
+                        virtual void visit( AsmStmt *stmt ) override { handleStmt( stmt ); return Parent::visit( stmt ); }
+                        virtual void visit( IfStmt *stmt ) override { handleStmt( stmt ); return Parent::visit( stmt ); }
+                        virtual void visit( WhileStmt *stmt ) override { handleStmt( stmt ); return Parent::visit( stmt ); }
+                        virtual void visit( ForStmt *stmt ) override { handleStmt( stmt ); return Parent::visit( stmt ); }
+                        virtual void visit( SwitchStmt *stmt ) override { handleStmt( stmt ); return Parent::visit( stmt ); }
+                        virtual void visit( CaseStmt *stmt ) override { handleStmt( stmt ); return Parent::visit( stmt ); }
+                        virtual void visit( BranchStmt *stmt ) override { handleStmt( stmt ); return Parent::visit( stmt ); }
+                        virtual void visit( ReturnStmt *stmt ) override { handleStmt( stmt ); return Parent::visit( stmt ); }
+                        virtual void visit( TryStmt *stmt ) override { handleStmt( stmt ); return Parent::visit( stmt ); }
+                        virtual void visit( CatchStmt *stmt ) override { handleStmt( stmt ); return Parent::visit( stmt ); }
+                        virtual void visit( FinallyStmt *stmt ) override { handleStmt( stmt ); return Parent::visit( stmt ); }
+                        virtual void visit( NullStmt *stmt ) override { handleStmt( stmt ); return Parent::visit( stmt ); }
+                        virtual void visit( DeclStmt *stmt ) override { handleStmt( stmt ); return Parent::visit( stmt ); }
+                        virtual void visit( ImplicitCtorDtorStmt *stmt ) override { handleStmt( stmt ); return Parent::visit( stmt ); }
                 };
 
-                struct InsertDtors final : public ObjDeclCollector, public WithStmtsToAdd {
+                class InsertDtors final : public ObjDeclCollector {
+                public:
                         /// insert destructor calls at the appropriate places.  must happen before CtorInit nodes are removed
                         /// (currently by FixInit)
                         static void insert( std::list< Declaration * > & translationUnit );
 
+                        typedef ObjDeclCollector Parent;
                         typedef std::list< ObjectDecl * > OrderedDecls;
                         typedef std::list< OrderedDecls > OrderedDeclsStack;
 
-                        InsertDtors( PassVisitor<LabelFinder> & finder ) : finder( finder ), labelVars( finder.pass.vars ) {}
-
-                        typedef ObjDeclCollector Parent;
-                        using Parent::previsit;
-
-                        void previsit( ObjectDecl * objDecl );
-                        void previsit( FunctionDecl * funcDecl );
-
-                        void previsit( CompoundStmt * compoundStmt );
-                        void postvisit( CompoundStmt * compoundStmt );
-                        void previsit( ReturnStmt * returnStmt );
-                        void previsit( BranchStmt * stmt );
+                        InsertDtors( LabelFinder & finder ) : finder( finder ), labelVars( finder.vars ) {}
+
+                        using Parent::visit;
+
+                        virtual void visit( ObjectDecl * objDecl ) override;
+                        virtual void visit( FunctionDecl * funcDecl ) override;
+
+                        virtual void visit( CompoundStmt * compoundStmt ) override;
+                        virtual void visit( ReturnStmt * returnStmt ) override;
+                        virtual void visit( BranchStmt * stmt ) override;
                 private:
                         void handleGoto( BranchStmt * stmt );
 
-                        PassVisitor<LabelFinder> & finder;
+                        LabelFinder & finder;
                         LabelFinder::LabelMap & labelVars;
                         OrderedDeclsStack reverseDeclOrder;
@@ -310 +333 @@
 
                 void InsertDtors::insert( std::list< Declaration * > & translationUnit ) {
-                        PassVisitor<LabelFinder> finder;
-                        PassVisitor<InsertDtors> inserter( finder );
+                        LabelFinder finder;
+                        InsertDtors inserter( finder );
                         acceptAll( translationUnit, inserter );
                 }
@@ -769 +792 @@
                 }
 
-                void ObjDeclCollector::previsit( CompoundStmt * ) {
-                        GuardValue( curVars );
-                }
-
-                void ObjDeclCollector::previsit( DeclStmt * stmt ) {
+                void ObjDeclCollector::visit( CompoundStmt * compoundStmt ) {
+                        ObjectSet prevVars = curVars;
+                        Parent::visit( compoundStmt );
+                        curVars = prevVars;
+                }
+
+                void ObjDeclCollector::visit( DeclStmt * stmt ) {
                         // keep track of all variables currently in scope
                         if ( ObjectDecl * objDecl = dynamic_cast< ObjectDecl * > ( stmt->get_decl() ) ) {
                                 curVars.push_back( objDecl );
                         } // if
-                }
-
-                void LabelFinder::previsit( Statement * stmt ) {
+                        Parent::visit( stmt );
+                }
+
+                void LabelFinder::handleStmt( Statement * stmt ) {
                         // for each label, remember the variables in scope at that label.
                         for ( Label l : stmt->get_labels() ) {
@@ -786 +812 @@
                         } // for
                 }
-
-                void LabelFinder::previsit( CompoundStmt * stmt ) {
-                        previsit( (Statement *)stmt );
-                        Parent::previsit( stmt );
-                }
-
-                void LabelFinder::previsit( DeclStmt * stmt ) {
-                        previsit( (Statement *)stmt );
-                        Parent::previsit( stmt );
-                }
-
 
                 template<typename Iterator, typename OutputIterator>
@@ -812 +827 @@
                 }
 
-                void InsertDtors::previsit( ObjectDecl * objDecl ) {
+                void InsertDtors::visit( ObjectDecl * objDecl ) {
                         // remember non-static destructed objects so that their destructors can be inserted later
                         if ( ! objDecl->get_storageClasses().is_static ) {
@@ -826 +841 @@
                                 } // if
                         } // if
-                }
-
-                void InsertDtors::previsit( FunctionDecl * funcDecl ) {
+                        Parent::visit( objDecl );
+                }
+
+                template< typename Visitor >
+                void handleFuncDecl( FunctionDecl * funcDecl, Visitor & visitor ) {
+                        maybeAccept( funcDecl->get_functionType(), visitor );
+                        maybeAccept( funcDecl->get_statements(), visitor );
+                }
+
+                void InsertDtors::visit( FunctionDecl * funcDecl ) {
                         // each function needs to have its own set of labels
-                        GuardValue( labelVars );
+                        ValueGuard< LabelFinder::LabelMap > oldLabels( labelVars );
                         labelVars.clear();
-                        maybeAccept( funcDecl->type, finder );
-                        maybeAccept( funcDecl->statements, finder );
-
-                        // all labels for this function have been collected, insert destructors as appropriate via implicit recursion.
-                }
-
-                void InsertDtors::previsit( CompoundStmt * compoundStmt ) {
+                        handleFuncDecl( funcDecl, finder );
+
+                        // all labels for this function have been collected, insert destructors as appropriate.
+                        // can't be Parent::mutate, because ObjDeclCollector bottoms out on FunctionDecl
+                        handleFuncDecl( funcDecl, *this );
+                }
+
+                void InsertDtors::visit( CompoundStmt * compoundStmt ) {
                         // visit statements - this will also populate reverseDeclOrder list.  don't want to dump all destructors
                         // when block is left, just the destructors associated with variables defined in this block, so push a new
                         // list to the top of the stack so that we can differentiate scopes
                         reverseDeclOrder.push_front( OrderedDecls() );
-                        Parent::previsit( compoundStmt );
-                }
-
-                void InsertDtors::postvisit( CompoundStmt * compoundStmt ) {
+                        Parent::visit( compoundStmt );
+
                         // add destructors for the current scope that we're exiting, unless the last statement is a return, which
                         // causes unreachable code warnings
@@ -856 +877 @@
                 }
 
-                void InsertDtors::previsit( ReturnStmt * ) {
+                void InsertDtors::visit( __attribute((unused)) ReturnStmt * returnStmt ) {
                         // return exits all scopes, so dump destructors for all scopes
                         for ( OrderedDecls & od : reverseDeclOrder ) {
-                                insertDtors( od.begin(), od.end(), back_inserter( stmtsToAddBefore ) );
+                                insertDtors( od.begin(), od.end(), back_inserter( stmtsToAdd ) );
                         } // for
                 }
@@ -907 +928 @@
                                         copy_if( rdo.begin(), rdo.end(), back_inserter( ordered ), [&]( ObjectDecl * objDecl ) { return needsDestructor.count( objDecl ); } );
                                 } // for
-                                insertDtors( ordered.begin(), ordered.end(), back_inserter( stmtsToAddBefore ) );
+                                insertDtors( ordered.begin(), ordered.end(), back_inserter( stmtsToAdd ) );
                         } // if
                 }
 
-                void InsertDtors::previsit( BranchStmt * stmt ) {
+                void InsertDtors::visit( BranchStmt * stmt ) {
                         switch( stmt->get_type() ) {
                           case BranchStmt::Continue:

src/Parser/ParseNode.h

@@ -44 +44 @@
 //##############################################################################
 
-typedef CodeLocation YYLTYPE;
-#define YYLTYPE_IS_DECLARED 1 /* alert the parser that we have our own definition */
-
 extern char * yyfilename;
 extern int yylineno;
-extern YYLTYPE yylloc;
 
 class ParseNode {
@@ -77 +73 @@
         ParseNode * next = nullptr;
         std::string * name = nullptr;
-        CodeLocation location = yylloc;
+        CodeLocation location = { yyfilename, yylineno };
 }; // ParseNode
 

src/Parser/lex.ll

@@ -26 +26 @@
 
 unsigned int column = 0;                                                                // position of the end of the last token parsed
-#define YY_USER_ACTION yylloc.first_line = yylineno; yylloc.first_column = column; column += yyleng; yylloc.last_column = column; yylloc.last_line = yylineno; yylloc.filename = yyfilename ? yyfilename : "";                          // trigger before each matching rule's action
+#define YY_USER_ACTION column += yyleng;                                // trigger before each matching rule's action
 
 #include <string>

src/Parser/parser.yy

@@ -116 +116 @@
 
 bool forall = false;                                                                    // aggregate have one or more forall qualifiers ?
-
-# define YYLLOC_DEFAULT(Cur, Rhs, N)                            \
-do                                                              \
-        if (N) {                                                      \
-                (Cur).first_line   = YYRHSLOC(Rhs, 1).first_line;           \
-                (Cur).first_column = YYRHSLOC(Rhs, 1).first_column;         \
-                (Cur).last_line    = YYRHSLOC(Rhs, N).last_line;            \
-                (Cur).last_column  = YYRHSLOC(Rhs, N).last_column;          \
-                (Cur).filename     = YYRHSLOC(Rhs, 1).filename;             \
-        } else {                                                      \
-                (Cur).first_line   = (Cur).last_line   =                    \
-                        YYRHSLOC(Rhs, 0).last_line;                               \
-                (Cur).first_column = (Cur).last_column =                    \
-                        YYRHSLOC(Rhs, 0).last_column;                             \
-                (Cur).filename     = YYRHSLOC(Rhs, 0).filename;             \
-        }                                                             \
-while (0)
 %}
 
@@ -363 +346 @@
 %precedence ELSE        // token precedence for start of else clause in IF/WAITFOR statement
 
-%locations
 
 %start translation_unit                                                                 // parse-tree root

src/SymTab/Autogen.cc

@@ -223 +223 @@
                         FunctionType * ftype = data.genType( refType );
 
-                        if ( concurrent_type && CodeGen::isDestructor( data.fname ) ) {
+                        if(concurrent_type && CodeGen::isDestructor( data.fname )) {
                                 ftype->parameters.front()->get_type()->set_mutex( true );
                         }

src/SynTree/BaseSyntaxNode.h

@@ -26 +26 @@
 
         virtual void accept( Visitor & v ) = 0;
-  virtual void print( std::ostream & os, int indent = 0 ) const = 0;
 };
 

src/tests/.expect/dtor-early-exit-ERR1.txt

@@ -1 @@
-dtor-early-exit.c:153:1 error: jump to label 'L1' crosses initialization of y Branch (Goto)
+dtor-early-exit.c:142:1 error: jump to label 'L1' crosses initialization of y Branch (Goto)
   with target: L1
   with original target: L1

src/tests/.expect/dtor-early-exit-ERR2.txt

@@ -1 @@
-dtor-early-exit.c:220:1 error: jump to label 'L2' crosses initialization of y Branch (Goto)
+dtor-early-exit.c:142:1 error: jump to label 'L2' crosses initialization of y Branch (Goto)
   with target: L2
   with original target: L2