Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • src/CodeGen/CodeGenerator.cc

    re149f77 rd22e90f  
    7979        }
    8080
    81         /* Using updateLocation at the beginning of a node and nextLine
     81        /* Using updateLocation at the beginning of a node and endl
    8282         * within a node should become the method of formating.
    8383         */
    8484        void CodeGenerator::updateLocation( CodeLocation const & to ) {
    85                 if ( !lineMarks ) {
    86                         return;
    87                 } else if ( currentLocation.followedBy( to, 0 ) ) {
     85                // skip if linemarks shouldn't appear or if codelocation is unset
     86                if ( !lineMarks || to.isUnset() ) return;
     87
     88                if ( currentLocation.followedBy( to, 0 ) ) {
    8889                        return;
    8990                } else if ( currentLocation.followedBy( to, 1 ) ) {
    9091                        output << "\n" << indent;
    91                         currentLocation.linenumber += 1;
     92                        currentLocation.first_line += 1;
    9293                } else if ( currentLocation.followedBy( to, 2 ) ) {
    9394                        output << "\n\n" << indent;
    94                         currentLocation.linenumber += 2;
    95                 } else {
    96                         output << "\n# " << to.linenumber << " \"" << to.filename
     95                        currentLocation.first_line += 2;
     96                } else {
     97                        output << "\n# " << to.first_line << " \"" << to.filename
    9798                               << "\"\n" << indent;
    9899                        currentLocation = to;
    … …  
    105106        }
    106107
    107         void CodeGenerator::nextLine() {
    108                 if ( !lineMarks ) {
    109                         output << "\n" << indent << std::flush;
    110                 }
    111         }
    112 
    113         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 ) {}
     108        // replace endl
     109        ostream & CodeGenerator::LineEnder::operator()( ostream & os ) const {
     110                // if ( !cg.lineMarks ) {
     111                //      os << "\n" << cg.indent << std::flush;
     112                // }
     113                os << "\n" << std::flush;
     114                cg.currentLocation.first_line++;
     115                // os << "/* did endl; current loc is: " << cg.currentLocation.first_line << "*/";
     116                return os;
     117        }
     118
     119        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 ) {}
    114120
    115121        string CodeGenerator::mangleName( DeclarationWithType * decl ) {
    … …  
    139145        } // CodeGenerator::genAttributes
    140146
     147        // *** BaseSyntaxNode
     148        void CodeGenerator::previsit( BaseSyntaxNode * node ) {
     149                // turn off automatic recursion for all nodes, to allow each visitor to
     150                // precisely control the order in which its children are visited.
     151                visit_children = false;
     152                updateLocation( node );
     153        }
     154
     155        // *** BaseSyntaxNode
     156        void CodeGenerator::postvisit( BaseSyntaxNode * node ) {
     157                std::stringstream ss;
     158                node->print( ss );
     159                assertf( false, "Unhandled node reached in CodeGenerator: %s", ss.str().c_str() );
     160        }
    141161
    142162        // *** Declarations
    143         void CodeGenerator::visit( FunctionDecl * functionDecl ) {
     163        void CodeGenerator::postvisit( FunctionDecl * functionDecl ) {
    144164                extension( functionDecl );
    145165                genAttributes( functionDecl->get_attributes() );
    … …  
    152172                asmName( functionDecl );
    153173
    154                 // acceptAll( functionDecl->get_oldDecls(), *this );
    155174                if ( functionDecl->get_statements() ) {
    156                         functionDecl->get_statements()->accept( *this );
    157                 } // if
    158         }
    159 
    160         void CodeGenerator::visit( ObjectDecl * objectDecl ) {
     175                        functionDecl->get_statements()->accept( *visitor );
     176                } // if
     177        }
     178
     179        void CodeGenerator::postvisit( ObjectDecl * objectDecl ) {
    161180                if (objectDecl->get_name().empty() && genC ) {
    162181                        // only generate an anonymous name when generating C code, otherwise it clutters the output too much
    … …  
    175194                if ( objectDecl->get_init() ) {
    176195                        output << " = ";
    177                         objectDecl->get_init()->accept( *this );
     196                        objectDecl->get_init()->accept( *visitor );
    178197                } // if
    179198
    180199                if ( objectDecl->get_bitfieldWidth() ) {
    181200                        output << ":";
    182                         objectDecl->get_bitfieldWidth()->accept( *this );
     201                        objectDecl->get_bitfieldWidth()->accept( *visitor );
    183202                } // if
    184203        }
    … …  
    203222                        ++indent;
    204223                        for ( std::list< Declaration* >::iterator i = memb.begin(); i != memb.end(); i++ ) {
    205                                 updateLocation( *i );
    206224                                output << indent;
    207                                 (*i)->accept( *this );
     225                                (*i)->accept( *visitor );
    208226                                output << ";" << endl;
    209227                        } // for
    … …  
    215233        }
    216234
    217         void CodeGenerator::visit( StructDecl * structDecl ) {
     235        void CodeGenerator::postvisit( StructDecl * structDecl ) {
    218236                extension( structDecl );
    219237                handleAggregate( structDecl, "struct " );
    220238        }
    221239
    222         void CodeGenerator::visit( UnionDecl * unionDecl ) {
     240        void CodeGenerator::postvisit( UnionDecl * unionDecl ) {
    223241                extension( unionDecl );
    224242                handleAggregate( unionDecl, "union " );
    225243        }
    226244
    227         void CodeGenerator::visit( EnumDecl * enumDecl ) {
     245        void CodeGenerator::postvisit( EnumDecl * enumDecl ) {
    228246                extension( enumDecl );
    229                 updateLocation( enumDecl );
    230247                output << "enum ";
    231248                genAttributes( enumDecl->get_attributes() );
    … …  
    242259                                ObjectDecl * obj = dynamic_cast< ObjectDecl* >( *i );
    243260                                assert( obj );
    244                                 updateLocation( obj );
    245261                                output << indent << mangleName( obj );
    246262                                if ( obj->get_init() ) {
    247263                                        output << " = ";
    248                                         obj->get_init()->accept( *this );
     264                                        obj->get_init()->accept( *visitor );
    249265                                } // if
    250266                                output << "," << endl;
    … …  
    257273        }
    258274
    259         void CodeGenerator::visit( TraitDecl * traitDecl ) {
     275        void CodeGenerator::postvisit( TraitDecl * traitDecl ) {
    260276                assertf( ! genC, "TraitDecls should not reach code generation." );
    261277                extension( traitDecl );
    … …  
    263279        }
    264280
    265         void CodeGenerator::visit( TypedefDecl * typeDecl ) {
     281        void CodeGenerator::postvisit( TypedefDecl * typeDecl ) {
    266282                assertf( ! genC, "Typedefs are removed and substituted in earlier passes." );
    267                 updateLocation( typeDecl );
    268283                output << "typedef ";
    269284                output << genType( typeDecl->get_base(), typeDecl->get_name(), pretty, genC ) << endl;
    270285        }
    271286
    272         void CodeGenerator::visit( TypeDecl * typeDecl ) {
     287        void CodeGenerator::postvisit( TypeDecl * typeDecl ) {
    273288                assertf( ! genC, "TypeDecls should not reach code generation." );
    274289                output << typeDecl->genTypeString() << " " << typeDecl->get_name();
    … …  
    283298        }
    284299
    285         void CodeGenerator::visit( Designation * designation ) {
     300        void CodeGenerator::postvisit( Designation * designation ) {
    286301                std::list< Expression * > designators = designation->get_designators();
    287302                if ( designators.size() == 0 ) return;
    … …  
    290305                                // if expression is a NameExpr or VariableExpr, then initializing aggregate member
    291306                                output << ".";
    292                                 des->accept( *this );
     307                                des->accept( *visitor );
    293308                        } else {
    294309                                // otherwise, it has to be a ConstantExpr or CastExpr, initializing array eleemnt
    295310                                output << "[";
    296                                 des->accept( *this );
     311                                des->accept( *visitor );
    297312                                output << "]";
    298313                        } // if
    … …  
    301316        }
    302317
    303         void CodeGenerator::visit( SingleInit * init ) {
    304                 init->get_value()->accept( *this );
    305         }
    306 
    307         void CodeGenerator::visit( ListInit * init ) {
     318        void CodeGenerator::postvisit( SingleInit * init ) {
     319                init->get_value()->accept( *visitor );
     320        }
     321
     322        void CodeGenerator::postvisit( ListInit * init ) {
    308323                auto initBegin = init->begin();
    309324                auto initEnd = init->end();
    … …  
    313328                output << "{ ";
    314329                for ( ; initBegin != initEnd && desigBegin != desigEnd; ) {
    315                         (*desigBegin)->accept( *this );
    316                         (*initBegin)->accept( *this );
     330                        (*desigBegin)->accept( *visitor );
     331                        (*initBegin)->accept( *visitor );
    317332                        ++initBegin, ++desigBegin;
    318333                        if ( initBegin != initEnd ) {
    … …  
    324339        }
    325340
    326         void CodeGenerator::visit( __attribute__((unused)) ConstructorInit * init ){
     341        void CodeGenerator::postvisit( ConstructorInit * init ){
    327342                assertf( ! genC, "ConstructorInit nodes should not reach code generation." );
    328343                // pseudo-output for constructor/destructor pairs
    329                 output << "<ctorinit>{" << std::endl << ++indent << "ctor: ";
    330                 maybeAccept( init->get_ctor(), *this );
    331                 output << ", " << std::endl << indent << "dtor: ";
    332                 maybeAccept( init->get_dtor(), *this );
    333                 output << std::endl << --indent << "}";
    334         }
    335 
    336         void CodeGenerator::visit( Constant * constant ) {
     344                output << "<ctorinit>{" << endl << ++indent << "ctor: ";
     345                maybeAccept( init->get_ctor(), *visitor );
     346                output << ", " << endl << indent << "dtor: ";
     347                maybeAccept( init->get_dtor(), *visitor );
     348                output << endl << --indent << "}";
     349        }
     350
     351        void CodeGenerator::postvisit( Constant * constant ) {
    337352                output << constant->get_value() ;
    338353        }
    339354
    340355        // *** Expressions
    341         void CodeGenerator::visit( ApplicationExpr * applicationExpr ) {
     356        void CodeGenerator::postvisit( ApplicationExpr * applicationExpr ) {
    342357                extension( applicationExpr );
    343358                if ( VariableExpr * varExpr = dynamic_cast< VariableExpr* >( applicationExpr->get_function() ) ) {
    … …  
    348363                                  case OT_INDEX:
    349364                                        assert( applicationExpr->get_args().size() == 2 );
    350                                         (*arg++)->accept( *this );
     365                                        (*arg++)->accept( *visitor );
    351366                                        output << "[";
    352                                         (*arg)->accept( *this );
     367                                        (*arg)->accept( *visitor );
    353368                                        output << "]";
    354369                                        break;
    … …  
    365380                                                // effects, so must still output this expression
    366381                                                output << "(";
    367                                                 (*arg++)->accept( *this );
     382                                                (*arg++)->accept( *visitor );
    368383                                                output << ") /* " << opInfo.inputName << " */";
    369384                                        } else if ( applicationExpr->get_args().size() == 2 ) {
    370385                                                // intrinsic two parameter constructors are essentially bitwise assignment
    371386                                                output << "(";
    372                                                 (*arg++)->accept( *this );
     387                                                (*arg++)->accept( *visitor );
    373388                                                output << opInfo.symbol;
    374                                                 (*arg)->accept( *this );
     389                                                (*arg)->accept( *visitor );
    375390                                                output << ") /* " << opInfo.inputName << " */";
    376391                                        } else {
    … …  
    385400                                        output << "(";
    386401                                        output << opInfo.symbol;
    387                                         (*arg)->accept( *this );
     402                                        (*arg)->accept( *visitor );
    388403                                        output << ")";
    389404                                        break;
    … …  
    392407                                  case OT_POSTFIXASSIGN:
    393408                                        assert( applicationExpr->get_args().size() == 1 );
    394                                         (*arg)->accept( *this );
     409                                        (*arg)->accept( *visitor );
    395410                                        output << opInfo.symbol;
    396411                                        break;
    … …  
    401416                                        assert( applicationExpr->get_args().size() == 2 );
    402417                                        output << "(";
    403                                         (*arg++)->accept( *this );
     418                                        (*arg++)->accept( *visitor );
    404419                                        output << opInfo.symbol;
    405                                         (*arg)->accept( *this );
     420                                        (*arg)->accept( *visitor );
    406421                                        output << ")";
    407422                                        break;
    … …  
    413428                                } // switch
    414429                        } else {
    415                                 varExpr->accept( *this );
     430                                varExpr->accept( *visitor );
    416431                                output << "(";
    417432                                genCommaList( applicationExpr->get_args().begin(), applicationExpr->get_args().end() );
    … …  
    419434                        } // if
    420435                } else {
    421                         applicationExpr->get_function()->accept( *this );
     436                        applicationExpr->get_function()->accept( *visitor );
    422437                        output << "(";
    423438                        genCommaList( applicationExpr->get_args().begin(), applicationExpr->get_args().end() );
    … …  
    426441        }
    427442
    428         void CodeGenerator::visit( UntypedExpr * untypedExpr ) {
     443        void CodeGenerator::postvisit( UntypedExpr * untypedExpr ) {
    429444                extension( untypedExpr );
    430445                if ( NameExpr * nameExpr = dynamic_cast< NameExpr* >( untypedExpr->get_function() ) ) {
    … …  
    435450                                  case OT_INDEX:
    436451                                        assert( untypedExpr->get_args().size() == 2 );
    437                                         (*arg++)->accept( *this );
     452                                        (*arg++)->accept( *visitor );
    438453                                        output << "[";
    439                                         (*arg)->accept( *this );
     454                                        (*arg)->accept( *visitor );
    440455                                        output << "]";
    441456                                        break;
    … …  
    450465                                                // effects, so must still output this expression
    451466                                                output << "(";
    452                                                 (*arg++)->accept( *this );
     467                                                (*arg++)->accept( *visitor );
    453468                                                output << ") /* " << opInfo.inputName << " */";
    454469                                        } else if ( untypedExpr->get_args().size() == 2 ) {
    455470                                                // intrinsic two parameter constructors are essentially bitwise assignment
    456471                                                output << "(";
    457                                                 (*arg++)->accept( *this );
     472                                                (*arg++)->accept( *visitor );
    458473                                                output << opInfo.symbol;
    459                                                 (*arg)->accept( *this );
     474                                                (*arg)->accept( *visitor );
    460475                                                output << ") /* " << opInfo.inputName << " */";
    461476                                        } else {
    462477                                                // no constructors with 0 or more than 2 parameters
    463                                                 assert( false );
     478                                                assertf( ! genC, "UntypedExpr constructor/destructor with 0 or more than 2 parameters." );
     479                                                output << "(";
     480                                                (*arg++)->accept( *visitor );
     481                                                output << opInfo.symbol << "{ ";
     482                                                genCommaList( arg, untypedExpr->get_args().end() );
     483                                                output << "}) /* " << opInfo.inputName << " */";
    464484                                        } // if
    465485                                        break;
    … …  
    471491                                        output << "(";
    472492                                        output << opInfo.symbol;
    473                                         (*arg)->accept( *this );
     493                                        (*arg)->accept( *visitor );
    474494                                        output << ")";
    475495                                        break;
    … …  
    478498                                  case OT_POSTFIXASSIGN:
    479499                                        assert( untypedExpr->get_args().size() == 1 );
    480                                         (*arg)->accept( *this );
     500                                        (*arg)->accept( *visitor );
    481501                                        output << opInfo.symbol;
    482502                                        break;
    … …  
    486506                                        assert( untypedExpr->get_args().size() == 2 );
    487507                                        output << "(";
    488                                         (*arg++)->accept( *this );
     508                                        (*arg++)->accept( *visitor );
    489509                                        output << opInfo.symbol;
    490                                         (*arg)->accept( *this );
     510                                        (*arg)->accept( *visitor );
    491511                                        output << ")";
    492512                                        break;
    … …  
    499519                                if ( nameExpr->get_name() == "..." ) { // case V1 ... V2 or case V1~V2
    500520                                        assert( untypedExpr->get_args().size() == 2 );
    501                                         (*untypedExpr->get_args().begin())->accept( *this );
     521                                        (*untypedExpr->get_args().begin())->accept( *visitor );
    502522                                        output << " ... ";
    503                                         (*--untypedExpr->get_args().end())->accept( *this );
     523                                        (*--untypedExpr->get_args().end())->accept( *visitor );
    504524                                } else {                                                                // builtin routines
    505                                         nameExpr->accept( *this );
     525                                        nameExpr->accept( *visitor );
    506526                                        output << "(";
    507527                                        genCommaList( untypedExpr->get_args().begin(), untypedExpr->get_args().end() );
    … …  
    510530                        } // if
    511531                } else {
    512                         untypedExpr->get_function()->accept( *this );
     532                        untypedExpr->get_function()->accept( *visitor );
    513533                        output << "(";
    514534                        genCommaList( untypedExpr->get_args().begin(), untypedExpr->get_args().end() );
    … …  
    517537        }
    518538
    519         void CodeGenerator::visit( RangeExpr * rangeExpr ) {
    520                 rangeExpr->get_low()->accept( *this );
     539        void CodeGenerator::postvisit( RangeExpr * rangeExpr ) {
     540                rangeExpr->get_low()->accept( *visitor );
    521541                output << " ... ";
    522                 rangeExpr->get_high()->accept( *this );
    523         }
    524 
    525         void CodeGenerator::visit( NameExpr * nameExpr ) {
     542                rangeExpr->get_high()->accept( *visitor );
     543        }
     544
     545        void CodeGenerator::postvisit( NameExpr * nameExpr ) {
    526546                extension( nameExpr );
    527547                OperatorInfo opInfo;
    … …  
    534554        }
    535555
    536         void CodeGenerator::visit( AddressExpr * addressExpr ) {
     556        void CodeGenerator::postvisit( AddressExpr * addressExpr ) {
    537557                extension( addressExpr );
    538558                output << "(&";
    539                 addressExpr->arg->accept( *this );
     559                addressExpr->arg->accept( *visitor );
    540560                output << ")";
    541561        }
    542562
    543         void CodeGenerator::visit( LabelAddressExpr *addressExpr ) {
     563        void CodeGenerator::postvisit( LabelAddressExpr *addressExpr ) {
    544564                extension( addressExpr );
    545565                output << "(&&" << addressExpr->arg << ")";
    546566        }
    547567
    548         void CodeGenerator::visit( CastExpr * castExpr ) {
     568        void CodeGenerator::postvisit( CastExpr * castExpr ) {
    549569                extension( castExpr );
    550570                output << "(";
    … …  
    559579                        output << ")";
    560580                } // if
    561                 castExpr->get_arg()->accept( *this );
     581                castExpr->get_arg()->accept( *visitor );
    562582                output << ")";
    563583        }
    564584
    565         void CodeGenerator::visit( VirtualCastExpr * castExpr ) {
     585        void CodeGenerator::postvisit( VirtualCastExpr * castExpr ) {
    566586                assertf( ! genC, "VirtualCastExpr should not reach code generation." );
    567587                extension( castExpr );
    568588                output << "(virtual ";
    569                 castExpr->get_arg()->accept( *this );
     589                castExpr->get_arg()->accept( *visitor );
    570590                output << ")";
    571591        }
    572592
    573         void CodeGenerator::visit( UntypedMemberExpr * memberExpr ) {
     593        void CodeGenerator::postvisit( UntypedMemberExpr * memberExpr ) {
    574594                assertf( ! genC, "UntypedMemberExpr should not reach code generation." );
    575595                extension( memberExpr );
    576                 memberExpr->get_aggregate()->accept( *this );
     596                memberExpr->get_aggregate()->accept( *visitor );
    577597                output << ".";
    578                 memberExpr->get_member()->accept( *this );
    579         }
    580 
    581         void CodeGenerator::visit( MemberExpr * memberExpr ) {
     598                memberExpr->get_member()->accept( *visitor );
     599        }
     600
     601        void CodeGenerator::postvisit( MemberExpr * memberExpr ) {
    582602                extension( memberExpr );
    583                 memberExpr->get_aggregate()->accept( *this );
     603                memberExpr->get_aggregate()->accept( *visitor );
    584604                output << "." << mangleName( memberExpr->get_member() );
    585605        }
    586606
    587         void CodeGenerator::visit( VariableExpr * variableExpr ) {
     607        void CodeGenerator::postvisit( VariableExpr * variableExpr ) {
    588608                extension( variableExpr );
    589609                OperatorInfo opInfo;
    … …  
    595615        }
    596616
    597         void CodeGenerator::visit( ConstantExpr * constantExpr ) {
     617        void CodeGenerator::postvisit( ConstantExpr * constantExpr ) {
    598618                assert( constantExpr->get_constant() );
    599619                extension( constantExpr );
    600                 constantExpr->get_constant()->accept( *this );
    601         }
    602 
    603         void CodeGenerator::visit( SizeofExpr * sizeofExpr ) {
     620                constantExpr->get_constant()->accept( *visitor );
     621        }
     622
     623        void CodeGenerator::postvisit( SizeofExpr * sizeofExpr ) {
    604624                extension( sizeofExpr );
    605625                output << "sizeof(";
    … …  
    607627                        output << genType( sizeofExpr->get_type(), "", pretty, genC );
    608628                } else {
    609                         sizeofExpr->get_expr()->accept( *this );
     629                        sizeofExpr->get_expr()->accept( *visitor );
    610630                } // if
    611631                output << ")";
    612632        }
    613633
    614         void CodeGenerator::visit( AlignofExpr * alignofExpr ) {
     634        void CodeGenerator::postvisit( AlignofExpr * alignofExpr ) {
    615635                // use GCC extension to avoid bumping std to C11
    616636                extension( alignofExpr );
    … …  
    619639                        output << genType( alignofExpr->get_type(), "", pretty, genC );
    620640                } else {
    621                         alignofExpr->get_expr()->accept( *this );
     641                        alignofExpr->get_expr()->accept( *visitor );
    622642                } // if
    623643                output << ")";
    624644        }
    625645
    626         void CodeGenerator::visit( UntypedOffsetofExpr * offsetofExpr ) {
     646        void CodeGenerator::postvisit( UntypedOffsetofExpr * offsetofExpr ) {
    627647                assertf( ! genC, "UntypedOffsetofExpr should not reach code generation." );
    628648                output << "offsetof(";
    … …  
    632652        }
    633653
    634         void CodeGenerator::visit( OffsetofExpr * offsetofExpr ) {
     654        void CodeGenerator::postvisit( OffsetofExpr * offsetofExpr ) {
    635655                // use GCC builtin
    636656                output << "__builtin_offsetof(";
    … …  
    640660        }
    641661
    642         void CodeGenerator::visit( OffsetPackExpr * offsetPackExpr ) {
     662        void CodeGenerator::postvisit( OffsetPackExpr * offsetPackExpr ) {
    643663                assertf( ! genC, "OffsetPackExpr should not reach code generation." );
    644664                output << "__CFA_offsetpack(" << genType( offsetPackExpr->get_type(), "", pretty, genC ) << ")";
    645665        }
    646666
    647         void CodeGenerator::visit( LogicalExpr * logicalExpr ) {
     667        void CodeGenerator::postvisit( LogicalExpr * logicalExpr ) {
    648668                extension( logicalExpr );
    649669                output << "(";
    650                 logicalExpr->get_arg1()->accept( *this );
     670                logicalExpr->get_arg1()->accept( *visitor );
    651671                if ( logicalExpr->get_isAnd() ) {
    652672                        output << " && ";
    … …  
    654674                        output << " || ";
    655675                } // if
    656                 logicalExpr->get_arg2()->accept( *this );
     676                logicalExpr->get_arg2()->accept( *visitor );
    657677                output << ")";
    658678        }
    659679
    660         void CodeGenerator::visit( ConditionalExpr * conditionalExpr ) {
     680        void CodeGenerator::postvisit( ConditionalExpr * conditionalExpr ) {
    661681                extension( conditionalExpr );
    662682                output << "(";
    663                 conditionalExpr->get_arg1()->accept( *this );
     683                conditionalExpr->get_arg1()->accept( *visitor );
    664684                output << " ? ";
    665                 conditionalExpr->get_arg2()->accept( *this );
     685                conditionalExpr->get_arg2()->accept( *visitor );
    666686                output << " : ";
    667                 conditionalExpr->get_arg3()->accept( *this );
     687                conditionalExpr->get_arg3()->accept( *visitor );
    668688                output << ")";
    669689        }
    670690
    671         void CodeGenerator::visit( CommaExpr * commaExpr ) {
     691        void CodeGenerator::postvisit( CommaExpr * commaExpr ) {
    672692                extension( commaExpr );
    673693                output << "(";
    … …  
    676696                        commaExpr->set_arg1( new CastExpr( commaExpr->get_arg1() ) );
    677697                }
    678                 commaExpr->get_arg1()->accept( *this );
     698                commaExpr->get_arg1()->accept( *visitor );
    679699                output << " , ";
    680                 commaExpr->get_arg2()->accept( *this );
     700                commaExpr->get_arg2()->accept( *visitor );
    681701                output << ")";
    682702        }
    683703
    684         void CodeGenerator::visit( TupleAssignExpr * tupleExpr ) {
     704        void CodeGenerator::postvisit( TupleAssignExpr * tupleExpr ) {
    685705                assertf( ! genC, "TupleAssignExpr should not reach code generation." );
    686                 tupleExpr->stmtExpr->accept( *this );
    687         }
    688 
    689         void CodeGenerator::visit( UntypedTupleExpr * tupleExpr ) {
     706                tupleExpr->stmtExpr->accept( *visitor );
     707        }
     708
     709        void CodeGenerator::postvisit( UntypedTupleExpr * tupleExpr ) {
    690710                assertf( ! genC, "UntypedTupleExpr should not reach code generation." );
    691711                extension( tupleExpr );
    … …  
    695715        }
    696716
    697         void CodeGenerator::visit( TupleExpr * tupleExpr ) {
     717        void CodeGenerator::postvisit( TupleExpr * tupleExpr ) {
    698718                assertf( ! genC, "TupleExpr should not reach code generation." );
    699719                extension( tupleExpr );
    … …  
    703723        }
    704724
    705         void CodeGenerator::visit( TupleIndexExpr * tupleExpr ) {
     725        void CodeGenerator::postvisit( TupleIndexExpr * tupleExpr ) {
    706726                assertf( ! genC, "TupleIndexExpr should not reach code generation." );
    707727                extension( tupleExpr );
    708                 tupleExpr->get_tuple()->accept( *this );
     728                tupleExpr->get_tuple()->accept( *visitor );
    709729                output << "." << tupleExpr->get_index();
    710730        }
    711731
    712         void CodeGenerator::visit( TypeExpr * typeExpr ) {
     732        void CodeGenerator::postvisit( TypeExpr * typeExpr ) {
    713733                // if ( genC ) std::cerr << "typeexpr still exists: " << typeExpr << std::endl;
    714734                // assertf( ! genC, "TypeExpr should not reach code generation." );
    … …  
    718738        }
    719739
    720         void CodeGenerator::visit( AsmExpr * asmExpr ) {
     740        void CodeGenerator::postvisit( AsmExpr * asmExpr ) {
    721741                if ( asmExpr->get_inout() ) {
    722742                        output << "[ ";
    723                         asmExpr->get_inout()->accept( *this );
     743                        asmExpr->get_inout()->accept( *visitor );
    724744                        output << " ] ";
    725745                } // if
    726                 asmExpr->get_constraint()->accept( *this );
     746                asmExpr->get_constraint()->accept( *visitor );
    727747                output << " ( ";
    728                 asmExpr->get_operand()->accept( *this );
     748                asmExpr->get_operand()->accept( *visitor );
    729749                output << " )";
    730750        }
    731751
    732         void CodeGenerator::visit( CompoundLiteralExpr *compLitExpr ) {
     752        void CodeGenerator::postvisit( CompoundLiteralExpr *compLitExpr ) {
    733753                assert( compLitExpr->get_result() && dynamic_cast< ListInit * > ( compLitExpr->get_initializer() ) );
    734754                output << "(" << genType( compLitExpr->get_result(), "", pretty, genC ) << ")";
    735                 compLitExpr->get_initializer()->accept( *this );
    736         }
    737 
    738         void CodeGenerator::visit( UniqueExpr * unqExpr ) {
     755                compLitExpr->get_initializer()->accept( *visitor );
     756        }
     757
     758        void CodeGenerator::postvisit( UniqueExpr * unqExpr ) {
    739759                assertf( ! genC, "Unique expressions should not reach code generation." );
    740760                output << "unq<" << unqExpr->get_id() << ">{ ";
    741                 unqExpr->get_expr()->accept( *this );
     761                unqExpr->get_expr()->accept( *visitor );
    742762                output << " }";
    743763        }
    744764
    745         void CodeGenerator::visit( StmtExpr * stmtExpr ) {
     765        void CodeGenerator::postvisit( StmtExpr * stmtExpr ) {
    746766                std::list< Statement * > & stmts = stmtExpr->get_statements()->get_kids();
    747                 updateLocation( stmtExpr );
    748                 output << "({" << std::endl;
     767                output << "({" << endl;
    749768                ++indent;
    750769                unsigned int numStmts = stmts.size();
    751770                unsigned int i = 0;
    752771                for ( Statement * stmt : stmts ) {
    753                         updateLocation( stmt );
    754772                        output << indent << printLabels( stmt->get_labels() );
    755773                        if ( i+1 == numStmts ) {
    … …  
    757775                                // cannot cast to void, otherwise the expression statement has no value
    758776                                if ( ExprStmt * exprStmt = dynamic_cast< ExprStmt * >( stmt ) ) {
    759                                         exprStmt->get_expr()->accept( *this );
     777                                        exprStmt->get_expr()->accept( *visitor );
    760778                                        output << ";" << endl;
    761779                                        ++i;
    … …  
    763781                                }
    764782                        }
    765                         stmt->accept( *this );
     783                        stmt->accept( *visitor );
    766784                        output << endl;
    767785                        if ( wantSpacing( stmt ) ) {
    … …  
    774792        }
    775793
     794        void CodeGenerator::postvisit( ConstructorExpr * expr ) {
     795                assertf( ! genC, "Unique expressions should not reach code generation." );
     796                expr->callExpr->accept( *visitor );
     797        }
     798
    776799        // *** Statements
    777         void CodeGenerator::visit( CompoundStmt * compoundStmt ) {
     800        void CodeGenerator::postvisit( CompoundStmt * compoundStmt ) {
    778801                std::list<Statement*> ks = compoundStmt->get_kids();
    779802                output << "{" << endl;
    … …  
    783806                for ( std::list<Statement *>::iterator i = ks.begin(); i != ks.end();  i++ ) {
    784807                        output << indent << printLabels( (*i)->get_labels() );
    785                         (*i)->accept( *this );
     808                        (*i)->accept( *visitor );
    786809
    787810                        output << endl;
    … …  
    795818        }
    796819
    797         void CodeGenerator::visit( ExprStmt * exprStmt ) {
     820        void CodeGenerator::postvisit( ExprStmt * exprStmt ) {
    798821                assert( exprStmt );
    799822                if ( genC ) {
    … …  
    801824                        exprStmt->set_expr( new CastExpr( exprStmt->get_expr() ) );
    802825                }
    803                 exprStmt->get_expr()->accept( *this );
     826                exprStmt->get_expr()->accept( *visitor );
    804827                output << ";";
    805828        }
    806829
    807         void CodeGenerator::visit( AsmStmt * asmStmt ) {
     830        void CodeGenerator::postvisit( AsmStmt * asmStmt ) {
    808831                output << "asm ";
    809832                if ( asmStmt->get_voltile() ) output << "volatile ";
    810833                if ( ! asmStmt->get_gotolabels().empty()  ) output << "goto ";
    811834                output << "( ";
    812                 if ( asmStmt->get_instruction() ) asmStmt->get_instruction()->accept( *this );
     835                if ( asmStmt->get_instruction() ) asmStmt->get_instruction()->accept( *visitor );
    813836                output << " : ";
    814837                genCommaList( asmStmt->get_output().begin(), asmStmt->get_output().end() );
    … …  
    828851        }
    829852
    830         void CodeGenerator::visit( AsmDecl * asmDecl ) {
     853        void CodeGenerator::postvisit( AsmDecl * asmDecl ) {
    831854                output << "asm ";
    832855                AsmStmt * asmStmt = asmDecl->get_stmt();
    833856                output << "( ";
    834                 if ( asmStmt->get_instruction() ) asmStmt->get_instruction()->accept( *this );
     857                if ( asmStmt->get_instruction() ) asmStmt->get_instruction()->accept( *visitor );
    835858                output << " )" ;
    836859        }
    837860
    838         void CodeGenerator::visit( IfStmt * ifStmt ) {
    839                 updateLocation( ifStmt );
     861        void CodeGenerator::postvisit( IfStmt * ifStmt ) {
    840862                output << "if ( ";
    841                 ifStmt->get_condition()->accept( *this );
     863                ifStmt->get_condition()->accept( *visitor );
    842864                output << " ) ";
    843865
    844                 ifStmt->get_thenPart()->accept( *this );
     866                ifStmt->get_thenPart()->accept( *visitor );
    845867
    846868                if ( ifStmt->get_elsePart() != 0) {
    847869                        output << " else ";
    848                         ifStmt->get_elsePart()->accept( *this );
    849                 } // if
    850         }
    851 
    852         void CodeGenerator::visit( SwitchStmt * switchStmt ) {
    853                 updateLocation( switchStmt );
     870                        ifStmt->get_elsePart()->accept( *visitor );
     871                } // if
     872        }
     873
     874        void CodeGenerator::postvisit( SwitchStmt * switchStmt ) {
    854875                output << "switch ( " ;
    855                 switchStmt->get_condition()->accept( *this );
     876                switchStmt->get_condition()->accept( *visitor );
    856877                output << " ) ";
    857878
    858                 output << "{" << std::endl;
     879                output << "{" << endl;
    859880                ++indent;
    860                 acceptAll( switchStmt->get_statements(), *this );
     881                acceptAll( switchStmt->get_statements(), *visitor );
    861882                --indent;
    862883                output << indent << "}";
    863884        }
    864885
    865         void CodeGenerator::visit( CaseStmt * caseStmt ) {
    866                 updateLocation( caseStmt );
    867                 output << indent;
     886        void CodeGenerator::postvisit( CaseStmt * caseStmt ) {
    868887                if ( caseStmt->isDefault()) {
    869888                        output << "default";
    870889                } else {
    871890                        output << "case ";
    872                         caseStmt->get_condition()->accept( *this );
    873                 } // if
    874                 output << ":\n";
     891                        caseStmt->get_condition()->accept( *visitor );
     892                } // if
     893                output << ":" << endl;
    875894
    876895                std::list<Statement *> sts = caseStmt->get_statements();
    … …  
    879898                for ( std::list<Statement *>::iterator i = sts.begin(); i != sts.end();  i++) {
    880899                        output << indent << printLabels( (*i)->get_labels() )  ;
    881                         (*i)->accept( *this );
     900                        (*i)->accept( *visitor );
    882901                        output << endl;
    883902                } // for
    … …  
    885904        }
    886905
    887         void CodeGenerator::visit( BranchStmt * branchStmt ) {
     906        void CodeGenerator::postvisit( BranchStmt * branchStmt ) {
    888907                switch ( branchStmt->get_type()) {
    889908                  case BranchStmt::Goto:
    … …  
    893912                                if ( branchStmt->get_computedTarget() != 0 ) {
    894913                                        output << "goto *";
    895                                         branchStmt->get_computedTarget()->accept( *this );
     914                                        branchStmt->get_computedTarget()->accept( *visitor );
    896915                                } // if
    897916                        } // if
    … …  
    907926        }
    908927
    909         void CodeGenerator::visit( ReturnStmt * returnStmt ) {
     928        void CodeGenerator::postvisit( ReturnStmt * returnStmt ) {
    910929                output << "return ";
    911                 maybeAccept( returnStmt->get_expr(), *this );
     930                maybeAccept( returnStmt->get_expr(), *visitor );
    912931                output << ";";
    913932        }
    914933
    915         void CodeGenerator::visit( ThrowStmt * throwStmt ) {
     934        void CodeGenerator::postvisit( ThrowStmt * throwStmt ) {
    916935                assertf( ! genC, "Throw statements should not reach code generation." );
    917936
    … …  
    920939                if (throwStmt->get_expr()) {
    921940                        output << " ";
    922                         throwStmt->get_expr()->accept( *this );
     941                        throwStmt->get_expr()->accept( *visitor );
    923942                }
    924943                if (throwStmt->get_target()) {
    925944                        output << " _At ";
    926                         throwStmt->get_target()->accept( *this );
     945                        throwStmt->get_target()->accept( *visitor );
    927946                }
    928947                output << ";";
    929948        }
    930949
    931         void CodeGenerator::visit( WhileStmt * whileStmt ) {
     950        void CodeGenerator::postvisit( WhileStmt * whileStmt ) {
    932951                if ( whileStmt->get_isDoWhile() ) {
    933952                        output << "do" ;
    934953                } else {
    935954                        output << "while (" ;
    936                         whileStmt->get_condition()->accept( *this );
     955                        whileStmt->get_condition()->accept( *visitor );
    937956                        output << ")";
    938957                } // if
    … …  
    940959
    941960                output << CodeGenerator::printLabels( whileStmt->get_body()->get_labels() );
    942                 whileStmt->get_body()->accept( *this );
     961                whileStmt->get_body()->accept( *visitor );
    943962
    944963                output << indent;
    … …  
    946965                if ( whileStmt->get_isDoWhile() ) {
    947966                        output << " while (" ;
    948                         whileStmt->get_condition()->accept( *this );
     967                        whileStmt->get_condition()->accept( *visitor );
    949968                        output << ");";
    950969                } // if
    951970        }
    952971
    953         void CodeGenerator::visit( ForStmt * forStmt ) {
     972        void CodeGenerator::postvisit( ForStmt * forStmt ) {
    954973                // initialization is always hoisted, so don't bother doing anything with that
    955974                output << "for (;";
    956975
    957976                if ( forStmt->get_condition() != 0 ) {
    958                         forStmt->get_condition()->accept( *this );
     977                        forStmt->get_condition()->accept( *visitor );
    959978                } // if
    960979                output << ";";
    … …  
    963982                        // cast the top-level expression to void to reduce gcc warnings.
    964983                        Expression * expr = new CastExpr( forStmt->get_increment() );
    965                         expr->accept( *this );
     984                        expr->accept( *visitor );
    966985                } // if
    967986                output << ") ";
    … …  
    969988                if ( forStmt->get_body() != 0 ) {
    970989                        output << CodeGenerator::printLabels( forStmt->get_body()->get_labels() );
    971                         forStmt->get_body()->accept( *this );
    972                 } // if
    973         }
    974 
    975         void CodeGenerator::visit( __attribute__((unused)) NullStmt * nullStmt ) {
     990                        forStmt->get_body()->accept( *visitor );
     991                } // if
     992        }
     993
     994        void CodeGenerator::postvisit( __attribute__((unused)) NullStmt * nullStmt ) {
    976995                //output << indent << CodeGenerator::printLabels( nullStmt->get_labels() );
    977996                output << "/* null statement */ ;";
    978997        }
    979998
    980         void CodeGenerator::visit( DeclStmt * declStmt ) {
    981                 declStmt->get_decl()->accept( *this );
     999        void CodeGenerator::postvisit( DeclStmt * declStmt ) {
     1000                declStmt->get_decl()->accept( *visitor );
    9821001
    9831002                if ( doSemicolon( declStmt->get_decl() ) ) {
    9841003                        output << ";";
    9851004                } // if
     1005        }
     1006
     1007        void CodeGenerator::postvisit( ImplicitCtorDtorStmt * stmt ) {
     1008                assertf( ! genC, "ImplicitCtorDtorStmts should not reach code generation." );
     1009                stmt->callStmt->accept( *visitor );
    9861010        }
    9871011
    … …  
    10011025        }
    10021026} // namespace CodeGen
    1003 
    1004 std::ostream & operator<<( std::ostream & out, const BaseSyntaxNode * node ) {
    1005         if ( node ) {
    1006                 node->print( out );
    1007         } else {
    1008                 out << "nullptr";
    1009         }
    1010         return out;
    1011 }
    10121027
    10131028// Local Variables: //
Note: See TracChangeset for help on using the changeset viewer.