Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • src/CodeGen/CodeGenerator.cc

    rd22e90f re149f77  
    7979        }
    8080
    81         /* Using updateLocation at the beginning of a node and endl
     81        /* Using updateLocation at the beginning of a node and nextLine
    8282         * within a node should become the method of formating.
    8383         */
    8484        void CodeGenerator::updateLocation( CodeLocation const & to ) {
    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 ) ) {
     85                if ( !lineMarks ) {
     86                        return;
     87                } else if ( currentLocation.followedBy( to, 0 ) ) {
    8988                        return;
    9089                } else if ( currentLocation.followedBy( to, 1 ) ) {
    9190                        output << "\n" << indent;
    92                         currentLocation.first_line += 1;
     91                        currentLocation.linenumber += 1;
    9392                } else if ( currentLocation.followedBy( to, 2 ) ) {
    9493                        output << "\n\n" << indent;
    95                         currentLocation.first_line += 2;
    96                 } else {
    97                         output << "\n# " << to.first_line << " \"" << to.filename
     94                        currentLocation.linenumber += 2;
     95                } else {
     96                        output << "\n# " << to.linenumber << " \"" << to.filename
    9897                               << "\"\n" << indent;
    9998                        currentLocation = to;
    … …  
    106105        }
    107106
    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 ) {}
     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 ) {}
    120114
    121115        string CodeGenerator::mangleName( DeclarationWithType * decl ) {
    … …  
    145139        } // CodeGenerator::genAttributes
    146140
    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         }
    161141
    162142        // *** Declarations
    163         void CodeGenerator::postvisit( FunctionDecl * functionDecl ) {
     143        void CodeGenerator::visit( FunctionDecl * functionDecl ) {
    164144                extension( functionDecl );
    165145                genAttributes( functionDecl->get_attributes() );
    … …  
    172152                asmName( functionDecl );
    173153
     154                // acceptAll( functionDecl->get_oldDecls(), *this );
    174155                if ( functionDecl->get_statements() ) {
    175                         functionDecl->get_statements()->accept( *visitor );
    176                 } // if
    177         }
    178 
    179         void CodeGenerator::postvisit( ObjectDecl * objectDecl ) {
     156                        functionDecl->get_statements()->accept( *this );
     157                } // if
     158        }
     159
     160        void CodeGenerator::visit( ObjectDecl * objectDecl ) {
    180161                if (objectDecl->get_name().empty() && genC ) {
    181162                        // only generate an anonymous name when generating C code, otherwise it clutters the output too much
    … …  
    194175                if ( objectDecl->get_init() ) {
    195176                        output << " = ";
    196                         objectDecl->get_init()->accept( *visitor );
     177                        objectDecl->get_init()->accept( *this );
    197178                } // if
    198179
    199180                if ( objectDecl->get_bitfieldWidth() ) {
    200181                        output << ":";
    201                         objectDecl->get_bitfieldWidth()->accept( *visitor );
     182                        objectDecl->get_bitfieldWidth()->accept( *this );
    202183                } // if
    203184        }
    … …  
    222203                        ++indent;
    223204                        for ( std::list< Declaration* >::iterator i = memb.begin(); i != memb.end(); i++ ) {
     205                                updateLocation( *i );
    224206                                output << indent;
    225                                 (*i)->accept( *visitor );
     207                                (*i)->accept( *this );
    226208                                output << ";" << endl;
    227209                        } // for
    … …  
    233215        }
    234216
    235         void CodeGenerator::postvisit( StructDecl * structDecl ) {
     217        void CodeGenerator::visit( StructDecl * structDecl ) {
    236218                extension( structDecl );
    237219                handleAggregate( structDecl, "struct " );
    238220        }
    239221
    240         void CodeGenerator::postvisit( UnionDecl * unionDecl ) {
     222        void CodeGenerator::visit( UnionDecl * unionDecl ) {
    241223                extension( unionDecl );
    242224                handleAggregate( unionDecl, "union " );
    243225        }
    244226
    245         void CodeGenerator::postvisit( EnumDecl * enumDecl ) {
     227        void CodeGenerator::visit( EnumDecl * enumDecl ) {
    246228                extension( enumDecl );
     229                updateLocation( enumDecl );
    247230                output << "enum ";
    248231                genAttributes( enumDecl->get_attributes() );
    … …  
    259242                                ObjectDecl * obj = dynamic_cast< ObjectDecl* >( *i );
    260243                                assert( obj );
     244                                updateLocation( obj );
    261245                                output << indent << mangleName( obj );
    262246                                if ( obj->get_init() ) {
    263247                                        output << " = ";
    264                                         obj->get_init()->accept( *visitor );
     248                                        obj->get_init()->accept( *this );
    265249                                } // if
    266250                                output << "," << endl;
    … …  
    273257        }
    274258
    275         void CodeGenerator::postvisit( TraitDecl * traitDecl ) {
     259        void CodeGenerator::visit( TraitDecl * traitDecl ) {
    276260                assertf( ! genC, "TraitDecls should not reach code generation." );
    277261                extension( traitDecl );
    … …  
    279263        }
    280264
    281         void CodeGenerator::postvisit( TypedefDecl * typeDecl ) {
     265        void CodeGenerator::visit( TypedefDecl * typeDecl ) {
    282266                assertf( ! genC, "Typedefs are removed and substituted in earlier passes." );
     267                updateLocation( typeDecl );
    283268                output << "typedef ";
    284269                output << genType( typeDecl->get_base(), typeDecl->get_name(), pretty, genC ) << endl;
    285270        }
    286271
    287         void CodeGenerator::postvisit( TypeDecl * typeDecl ) {
     272        void CodeGenerator::visit( TypeDecl * typeDecl ) {
    288273                assertf( ! genC, "TypeDecls should not reach code generation." );
    289274                output << typeDecl->genTypeString() << " " << typeDecl->get_name();
    … …  
    298283        }
    299284
    300         void CodeGenerator::postvisit( Designation * designation ) {
     285        void CodeGenerator::visit( Designation * designation ) {
    301286                std::list< Expression * > designators = designation->get_designators();
    302287                if ( designators.size() == 0 ) return;
    … …  
    305290                                // if expression is a NameExpr or VariableExpr, then initializing aggregate member
    306291                                output << ".";
    307                                 des->accept( *visitor );
     292                                des->accept( *this );
    308293                        } else {
    309294                                // otherwise, it has to be a ConstantExpr or CastExpr, initializing array eleemnt
    310295                                output << "[";
    311                                 des->accept( *visitor );
     296                                des->accept( *this );
    312297                                output << "]";
    313298                        } // if
    … …  
    316301        }
    317302
    318         void CodeGenerator::postvisit( SingleInit * init ) {
    319                 init->get_value()->accept( *visitor );
    320         }
    321 
    322         void CodeGenerator::postvisit( ListInit * init ) {
     303        void CodeGenerator::visit( SingleInit * init ) {
     304                init->get_value()->accept( *this );
     305        }
     306
     307        void CodeGenerator::visit( ListInit * init ) {
    323308                auto initBegin = init->begin();
    324309                auto initEnd = init->end();
    … …  
    328313                output << "{ ";
    329314                for ( ; initBegin != initEnd && desigBegin != desigEnd; ) {
    330                         (*desigBegin)->accept( *visitor );
    331                         (*initBegin)->accept( *visitor );
     315                        (*desigBegin)->accept( *this );
     316                        (*initBegin)->accept( *this );
    332317                        ++initBegin, ++desigBegin;
    333318                        if ( initBegin != initEnd ) {
    … …  
    339324        }
    340325
    341         void CodeGenerator::postvisit( ConstructorInit * init ){
     326        void CodeGenerator::visit( __attribute__((unused)) ConstructorInit * init ){
    342327                assertf( ! genC, "ConstructorInit nodes should not reach code generation." );
    343328                // pseudo-output for constructor/destructor pairs
    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 ) {
     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 ) {
    352337                output << constant->get_value() ;
    353338        }
    354339
    355340        // *** Expressions
    356         void CodeGenerator::postvisit( ApplicationExpr * applicationExpr ) {
     341        void CodeGenerator::visit( ApplicationExpr * applicationExpr ) {
    357342                extension( applicationExpr );
    358343                if ( VariableExpr * varExpr = dynamic_cast< VariableExpr* >( applicationExpr->get_function() ) ) {
    … …  
    363348                                  case OT_INDEX:
    364349                                        assert( applicationExpr->get_args().size() == 2 );
    365                                         (*arg++)->accept( *visitor );
     350                                        (*arg++)->accept( *this );
    366351                                        output << "[";
    367                                         (*arg)->accept( *visitor );
     352                                        (*arg)->accept( *this );
    368353                                        output << "]";
    369354                                        break;
    … …  
    380365                                                // effects, so must still output this expression
    381366                                                output << "(";
    382                                                 (*arg++)->accept( *visitor );
     367                                                (*arg++)->accept( *this );
    383368                                                output << ") /* " << opInfo.inputName << " */";
    384369                                        } else if ( applicationExpr->get_args().size() == 2 ) {
    385370                                                // intrinsic two parameter constructors are essentially bitwise assignment
    386371                                                output << "(";
    387                                                 (*arg++)->accept( *visitor );
     372                                                (*arg++)->accept( *this );
    388373                                                output << opInfo.symbol;
    389                                                 (*arg)->accept( *visitor );
     374                                                (*arg)->accept( *this );
    390375                                                output << ") /* " << opInfo.inputName << " */";
    391376                                        } else {
    … …  
    400385                                        output << "(";
    401386                                        output << opInfo.symbol;
    402                                         (*arg)->accept( *visitor );
     387                                        (*arg)->accept( *this );
    403388                                        output << ")";
    404389                                        break;
    … …  
    407392                                  case OT_POSTFIXASSIGN:
    408393                                        assert( applicationExpr->get_args().size() == 1 );
    409                                         (*arg)->accept( *visitor );
     394                                        (*arg)->accept( *this );
    410395                                        output << opInfo.symbol;
    411396                                        break;
    … …  
    416401                                        assert( applicationExpr->get_args().size() == 2 );
    417402                                        output << "(";
    418                                         (*arg++)->accept( *visitor );
     403                                        (*arg++)->accept( *this );
    419404                                        output << opInfo.symbol;
    420                                         (*arg)->accept( *visitor );
     405                                        (*arg)->accept( *this );
    421406                                        output << ")";
    422407                                        break;
    … …  
    428413                                } // switch
    429414                        } else {
    430                                 varExpr->accept( *visitor );
     415                                varExpr->accept( *this );
    431416                                output << "(";
    432417                                genCommaList( applicationExpr->get_args().begin(), applicationExpr->get_args().end() );
    … …  
    434419                        } // if
    435420                } else {
    436                         applicationExpr->get_function()->accept( *visitor );
     421                        applicationExpr->get_function()->accept( *this );
    437422                        output << "(";
    438423                        genCommaList( applicationExpr->get_args().begin(), applicationExpr->get_args().end() );
    … …  
    441426        }
    442427
    443         void CodeGenerator::postvisit( UntypedExpr * untypedExpr ) {
     428        void CodeGenerator::visit( UntypedExpr * untypedExpr ) {
    444429                extension( untypedExpr );
    445430                if ( NameExpr * nameExpr = dynamic_cast< NameExpr* >( untypedExpr->get_function() ) ) {
    … …  
    450435                                  case OT_INDEX:
    451436                                        assert( untypedExpr->get_args().size() == 2 );
    452                                         (*arg++)->accept( *visitor );
     437                                        (*arg++)->accept( *this );
    453438                                        output << "[";
    454                                         (*arg)->accept( *visitor );
     439                                        (*arg)->accept( *this );
    455440                                        output << "]";
    456441                                        break;
    … …  
    465450                                                // effects, so must still output this expression
    466451                                                output << "(";
    467                                                 (*arg++)->accept( *visitor );
     452                                                (*arg++)->accept( *this );
    468453                                                output << ") /* " << opInfo.inputName << " */";
    469454                                        } else if ( untypedExpr->get_args().size() == 2 ) {
    470455                                                // intrinsic two parameter constructors are essentially bitwise assignment
    471456                                                output << "(";
    472                                                 (*arg++)->accept( *visitor );
     457                                                (*arg++)->accept( *this );
    473458                                                output << opInfo.symbol;
    474                                                 (*arg)->accept( *visitor );
     459                                                (*arg)->accept( *this );
    475460                                                output << ") /* " << opInfo.inputName << " */";
    476461                                        } else {
    477462                                                // no constructors with 0 or more than 2 parameters
    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 << " */";
     463                                                assert( false );
    484464                                        } // if
    485465                                        break;
    … …  
    491471                                        output << "(";
    492472                                        output << opInfo.symbol;
    493                                         (*arg)->accept( *visitor );
     473                                        (*arg)->accept( *this );
    494474                                        output << ")";
    495475                                        break;
    … …  
    498478                                  case OT_POSTFIXASSIGN:
    499479                                        assert( untypedExpr->get_args().size() == 1 );
    500                                         (*arg)->accept( *visitor );
     480                                        (*arg)->accept( *this );
    501481                                        output << opInfo.symbol;
    502482                                        break;
    … …  
    506486                                        assert( untypedExpr->get_args().size() == 2 );
    507487                                        output << "(";
    508                                         (*arg++)->accept( *visitor );
     488                                        (*arg++)->accept( *this );
    509489                                        output << opInfo.symbol;
    510                                         (*arg)->accept( *visitor );
     490                                        (*arg)->accept( *this );
    511491                                        output << ")";
    512492                                        break;
    … …  
    519499                                if ( nameExpr->get_name() == "..." ) { // case V1 ... V2 or case V1~V2
    520500                                        assert( untypedExpr->get_args().size() == 2 );
    521                                         (*untypedExpr->get_args().begin())->accept( *visitor );
     501                                        (*untypedExpr->get_args().begin())->accept( *this );
    522502                                        output << " ... ";
    523                                         (*--untypedExpr->get_args().end())->accept( *visitor );
     503                                        (*--untypedExpr->get_args().end())->accept( *this );
    524504                                } else {                                                                // builtin routines
    525                                         nameExpr->accept( *visitor );
     505                                        nameExpr->accept( *this );
    526506                                        output << "(";
    527507                                        genCommaList( untypedExpr->get_args().begin(), untypedExpr->get_args().end() );
    … …  
    530510                        } // if
    531511                } else {
    532                         untypedExpr->get_function()->accept( *visitor );
     512                        untypedExpr->get_function()->accept( *this );
    533513                        output << "(";
    534514                        genCommaList( untypedExpr->get_args().begin(), untypedExpr->get_args().end() );
    … …  
    537517        }
    538518
    539         void CodeGenerator::postvisit( RangeExpr * rangeExpr ) {
    540                 rangeExpr->get_low()->accept( *visitor );
     519        void CodeGenerator::visit( RangeExpr * rangeExpr ) {
     520                rangeExpr->get_low()->accept( *this );
    541521                output << " ... ";
    542                 rangeExpr->get_high()->accept( *visitor );
    543         }
    544 
    545         void CodeGenerator::postvisit( NameExpr * nameExpr ) {
     522                rangeExpr->get_high()->accept( *this );
     523        }
     524
     525        void CodeGenerator::visit( NameExpr * nameExpr ) {
    546526                extension( nameExpr );
    547527                OperatorInfo opInfo;
    … …  
    554534        }
    555535
    556         void CodeGenerator::postvisit( AddressExpr * addressExpr ) {
     536        void CodeGenerator::visit( AddressExpr * addressExpr ) {
    557537                extension( addressExpr );
    558538                output << "(&";
    559                 addressExpr->arg->accept( *visitor );
     539                addressExpr->arg->accept( *this );
    560540                output << ")";
    561541        }
    562542
    563         void CodeGenerator::postvisit( LabelAddressExpr *addressExpr ) {
     543        void CodeGenerator::visit( LabelAddressExpr *addressExpr ) {
    564544                extension( addressExpr );
    565545                output << "(&&" << addressExpr->arg << ")";
    566546        }
    567547
    568         void CodeGenerator::postvisit( CastExpr * castExpr ) {
     548        void CodeGenerator::visit( CastExpr * castExpr ) {
    569549                extension( castExpr );
    570550                output << "(";
    … …  
    579559                        output << ")";
    580560                } // if
    581                 castExpr->get_arg()->accept( *visitor );
     561                castExpr->get_arg()->accept( *this );
    582562                output << ")";
    583563        }
    584564
    585         void CodeGenerator::postvisit( VirtualCastExpr * castExpr ) {
     565        void CodeGenerator::visit( VirtualCastExpr * castExpr ) {
    586566                assertf( ! genC, "VirtualCastExpr should not reach code generation." );
    587567                extension( castExpr );
    588568                output << "(virtual ";
    589                 castExpr->get_arg()->accept( *visitor );
     569                castExpr->get_arg()->accept( *this );
    590570                output << ")";
    591571        }
    592572
    593         void CodeGenerator::postvisit( UntypedMemberExpr * memberExpr ) {
     573        void CodeGenerator::visit( UntypedMemberExpr * memberExpr ) {
    594574                assertf( ! genC, "UntypedMemberExpr should not reach code generation." );
    595575                extension( memberExpr );
    596                 memberExpr->get_aggregate()->accept( *visitor );
     576                memberExpr->get_aggregate()->accept( *this );
    597577                output << ".";
    598                 memberExpr->get_member()->accept( *visitor );
    599         }
    600 
    601         void CodeGenerator::postvisit( MemberExpr * memberExpr ) {
     578                memberExpr->get_member()->accept( *this );
     579        }
     580
     581        void CodeGenerator::visit( MemberExpr * memberExpr ) {
    602582                extension( memberExpr );
    603                 memberExpr->get_aggregate()->accept( *visitor );
     583                memberExpr->get_aggregate()->accept( *this );
    604584                output << "." << mangleName( memberExpr->get_member() );
    605585        }
    606586
    607         void CodeGenerator::postvisit( VariableExpr * variableExpr ) {
     587        void CodeGenerator::visit( VariableExpr * variableExpr ) {
    608588                extension( variableExpr );
    609589                OperatorInfo opInfo;
    … …  
    615595        }
    616596
    617         void CodeGenerator::postvisit( ConstantExpr * constantExpr ) {
     597        void CodeGenerator::visit( ConstantExpr * constantExpr ) {
    618598                assert( constantExpr->get_constant() );
    619599                extension( constantExpr );
    620                 constantExpr->get_constant()->accept( *visitor );
    621         }
    622 
    623         void CodeGenerator::postvisit( SizeofExpr * sizeofExpr ) {
     600                constantExpr->get_constant()->accept( *this );
     601        }
     602
     603        void CodeGenerator::visit( SizeofExpr * sizeofExpr ) {
    624604                extension( sizeofExpr );
    625605                output << "sizeof(";
    … …  
    627607                        output << genType( sizeofExpr->get_type(), "", pretty, genC );
    628608                } else {
    629                         sizeofExpr->get_expr()->accept( *visitor );
     609                        sizeofExpr->get_expr()->accept( *this );
    630610                } // if
    631611                output << ")";
    632612        }
    633613
    634         void CodeGenerator::postvisit( AlignofExpr * alignofExpr ) {
     614        void CodeGenerator::visit( AlignofExpr * alignofExpr ) {
    635615                // use GCC extension to avoid bumping std to C11
    636616                extension( alignofExpr );
    … …  
    639619                        output << genType( alignofExpr->get_type(), "", pretty, genC );
    640620                } else {
    641                         alignofExpr->get_expr()->accept( *visitor );
     621                        alignofExpr->get_expr()->accept( *this );
    642622                } // if
    643623                output << ")";
    644624        }
    645625
    646         void CodeGenerator::postvisit( UntypedOffsetofExpr * offsetofExpr ) {
     626        void CodeGenerator::visit( UntypedOffsetofExpr * offsetofExpr ) {
    647627                assertf( ! genC, "UntypedOffsetofExpr should not reach code generation." );
    648628                output << "offsetof(";
    … …  
    652632        }
    653633
    654         void CodeGenerator::postvisit( OffsetofExpr * offsetofExpr ) {
     634        void CodeGenerator::visit( OffsetofExpr * offsetofExpr ) {
    655635                // use GCC builtin
    656636                output << "__builtin_offsetof(";
    … …  
    660640        }
    661641
    662         void CodeGenerator::postvisit( OffsetPackExpr * offsetPackExpr ) {
     642        void CodeGenerator::visit( OffsetPackExpr * offsetPackExpr ) {
    663643                assertf( ! genC, "OffsetPackExpr should not reach code generation." );
    664644                output << "__CFA_offsetpack(" << genType( offsetPackExpr->get_type(), "", pretty, genC ) << ")";
    665645        }
    666646
    667         void CodeGenerator::postvisit( LogicalExpr * logicalExpr ) {
     647        void CodeGenerator::visit( LogicalExpr * logicalExpr ) {
    668648                extension( logicalExpr );
    669649                output << "(";
    670                 logicalExpr->get_arg1()->accept( *visitor );
     650                logicalExpr->get_arg1()->accept( *this );
    671651                if ( logicalExpr->get_isAnd() ) {
    672652                        output << " && ";
    … …  
    674654                        output << " || ";
    675655                } // if
    676                 logicalExpr->get_arg2()->accept( *visitor );
     656                logicalExpr->get_arg2()->accept( *this );
    677657                output << ")";
    678658        }
    679659
    680         void CodeGenerator::postvisit( ConditionalExpr * conditionalExpr ) {
     660        void CodeGenerator::visit( ConditionalExpr * conditionalExpr ) {
    681661                extension( conditionalExpr );
    682662                output << "(";
    683                 conditionalExpr->get_arg1()->accept( *visitor );
     663                conditionalExpr->get_arg1()->accept( *this );
    684664                output << " ? ";
    685                 conditionalExpr->get_arg2()->accept( *visitor );
     665                conditionalExpr->get_arg2()->accept( *this );
    686666                output << " : ";
    687                 conditionalExpr->get_arg3()->accept( *visitor );
     667                conditionalExpr->get_arg3()->accept( *this );
    688668                output << ")";
    689669        }
    690670
    691         void CodeGenerator::postvisit( CommaExpr * commaExpr ) {
     671        void CodeGenerator::visit( CommaExpr * commaExpr ) {
    692672                extension( commaExpr );
    693673                output << "(";
    … …  
    696676                        commaExpr->set_arg1( new CastExpr( commaExpr->get_arg1() ) );
    697677                }
    698                 commaExpr->get_arg1()->accept( *visitor );
     678                commaExpr->get_arg1()->accept( *this );
    699679                output << " , ";
    700                 commaExpr->get_arg2()->accept( *visitor );
     680                commaExpr->get_arg2()->accept( *this );
    701681                output << ")";
    702682        }
    703683
    704         void CodeGenerator::postvisit( TupleAssignExpr * tupleExpr ) {
     684        void CodeGenerator::visit( TupleAssignExpr * tupleExpr ) {
    705685                assertf( ! genC, "TupleAssignExpr should not reach code generation." );
    706                 tupleExpr->stmtExpr->accept( *visitor );
    707         }
    708 
    709         void CodeGenerator::postvisit( UntypedTupleExpr * tupleExpr ) {
     686                tupleExpr->stmtExpr->accept( *this );
     687        }
     688
     689        void CodeGenerator::visit( UntypedTupleExpr * tupleExpr ) {
    710690                assertf( ! genC, "UntypedTupleExpr should not reach code generation." );
    711691                extension( tupleExpr );
    … …  
    715695        }
    716696
    717         void CodeGenerator::postvisit( TupleExpr * tupleExpr ) {
     697        void CodeGenerator::visit( TupleExpr * tupleExpr ) {
    718698                assertf( ! genC, "TupleExpr should not reach code generation." );
    719699                extension( tupleExpr );
    … …  
    723703        }
    724704
    725         void CodeGenerator::postvisit( TupleIndexExpr * tupleExpr ) {
     705        void CodeGenerator::visit( TupleIndexExpr * tupleExpr ) {
    726706                assertf( ! genC, "TupleIndexExpr should not reach code generation." );
    727707                extension( tupleExpr );
    728                 tupleExpr->get_tuple()->accept( *visitor );
     708                tupleExpr->get_tuple()->accept( *this );
    729709                output << "." << tupleExpr->get_index();
    730710        }
    731711
    732         void CodeGenerator::postvisit( TypeExpr * typeExpr ) {
     712        void CodeGenerator::visit( TypeExpr * typeExpr ) {
    733713                // if ( genC ) std::cerr << "typeexpr still exists: " << typeExpr << std::endl;
    734714                // assertf( ! genC, "TypeExpr should not reach code generation." );
    … …  
    738718        }
    739719
    740         void CodeGenerator::postvisit( AsmExpr * asmExpr ) {
     720        void CodeGenerator::visit( AsmExpr * asmExpr ) {
    741721                if ( asmExpr->get_inout() ) {
    742722                        output << "[ ";
    743                         asmExpr->get_inout()->accept( *visitor );
     723                        asmExpr->get_inout()->accept( *this );
    744724                        output << " ] ";
    745725                } // if
    746                 asmExpr->get_constraint()->accept( *visitor );
     726                asmExpr->get_constraint()->accept( *this );
    747727                output << " ( ";
    748                 asmExpr->get_operand()->accept( *visitor );
     728                asmExpr->get_operand()->accept( *this );
    749729                output << " )";
    750730        }
    751731
    752         void CodeGenerator::postvisit( CompoundLiteralExpr *compLitExpr ) {
     732        void CodeGenerator::visit( CompoundLiteralExpr *compLitExpr ) {
    753733                assert( compLitExpr->get_result() && dynamic_cast< ListInit * > ( compLitExpr->get_initializer() ) );
    754734                output << "(" << genType( compLitExpr->get_result(), "", pretty, genC ) << ")";
    755                 compLitExpr->get_initializer()->accept( *visitor );
    756         }
    757 
    758         void CodeGenerator::postvisit( UniqueExpr * unqExpr ) {
     735                compLitExpr->get_initializer()->accept( *this );
     736        }
     737
     738        void CodeGenerator::visit( UniqueExpr * unqExpr ) {
    759739                assertf( ! genC, "Unique expressions should not reach code generation." );
    760740                output << "unq<" << unqExpr->get_id() << ">{ ";
    761                 unqExpr->get_expr()->accept( *visitor );
     741                unqExpr->get_expr()->accept( *this );
    762742                output << " }";
    763743        }
    764744
    765         void CodeGenerator::postvisit( StmtExpr * stmtExpr ) {
     745        void CodeGenerator::visit( StmtExpr * stmtExpr ) {
    766746                std::list< Statement * > & stmts = stmtExpr->get_statements()->get_kids();
    767                 output << "({" << endl;
     747                updateLocation( stmtExpr );
     748                output << "({" << std::endl;
    768749                ++indent;
    769750                unsigned int numStmts = stmts.size();
    770751                unsigned int i = 0;
    771752                for ( Statement * stmt : stmts ) {
     753                        updateLocation( stmt );
    772754                        output << indent << printLabels( stmt->get_labels() );
    773755                        if ( i+1 == numStmts ) {
    … …  
    775757                                // cannot cast to void, otherwise the expression statement has no value
    776758                                if ( ExprStmt * exprStmt = dynamic_cast< ExprStmt * >( stmt ) ) {
    777                                         exprStmt->get_expr()->accept( *visitor );
     759                                        exprStmt->get_expr()->accept( *this );
    778760                                        output << ";" << endl;
    779761                                        ++i;
    … …  
    781763                                }
    782764                        }
    783                         stmt->accept( *visitor );
     765                        stmt->accept( *this );
    784766                        output << endl;
    785767                        if ( wantSpacing( stmt ) ) {
    … …  
    792774        }
    793775
    794         void CodeGenerator::postvisit( ConstructorExpr * expr ) {
    795                 assertf( ! genC, "Unique expressions should not reach code generation." );
    796                 expr->callExpr->accept( *visitor );
    797         }
    798 
    799776        // *** Statements
    800         void CodeGenerator::postvisit( CompoundStmt * compoundStmt ) {
     777        void CodeGenerator::visit( CompoundStmt * compoundStmt ) {
    801778                std::list<Statement*> ks = compoundStmt->get_kids();
    802779                output << "{" << endl;
    … …  
    806783                for ( std::list<Statement *>::iterator i = ks.begin(); i != ks.end();  i++ ) {
    807784                        output << indent << printLabels( (*i)->get_labels() );
    808                         (*i)->accept( *visitor );
     785                        (*i)->accept( *this );
    809786
    810787                        output << endl;
    … …  
    818795        }
    819796
    820         void CodeGenerator::postvisit( ExprStmt * exprStmt ) {
     797        void CodeGenerator::visit( ExprStmt * exprStmt ) {
    821798                assert( exprStmt );
    822799                if ( genC ) {
    … …  
    824801                        exprStmt->set_expr( new CastExpr( exprStmt->get_expr() ) );
    825802                }
    826                 exprStmt->get_expr()->accept( *visitor );
     803                exprStmt->get_expr()->accept( *this );
    827804                output << ";";
    828805        }
    829806
    830         void CodeGenerator::postvisit( AsmStmt * asmStmt ) {
     807        void CodeGenerator::visit( AsmStmt * asmStmt ) {
    831808                output << "asm ";
    832809                if ( asmStmt->get_voltile() ) output << "volatile ";
    833810                if ( ! asmStmt->get_gotolabels().empty()  ) output << "goto ";
    834811                output << "( ";
    835                 if ( asmStmt->get_instruction() ) asmStmt->get_instruction()->accept( *visitor );
     812                if ( asmStmt->get_instruction() ) asmStmt->get_instruction()->accept( *this );
    836813                output << " : ";
    837814                genCommaList( asmStmt->get_output().begin(), asmStmt->get_output().end() );
    … …  
    851828        }
    852829
    853         void CodeGenerator::postvisit( AsmDecl * asmDecl ) {
     830        void CodeGenerator::visit( AsmDecl * asmDecl ) {
    854831                output << "asm ";
    855832                AsmStmt * asmStmt = asmDecl->get_stmt();
    856833                output << "( ";
    857                 if ( asmStmt->get_instruction() ) asmStmt->get_instruction()->accept( *visitor );
     834                if ( asmStmt->get_instruction() ) asmStmt->get_instruction()->accept( *this );
    858835                output << " )" ;
    859836        }
    860837
    861         void CodeGenerator::postvisit( IfStmt * ifStmt ) {
     838        void CodeGenerator::visit( IfStmt * ifStmt ) {
     839                updateLocation( ifStmt );
    862840                output << "if ( ";
    863                 ifStmt->get_condition()->accept( *visitor );
     841                ifStmt->get_condition()->accept( *this );
    864842                output << " ) ";
    865843
    866                 ifStmt->get_thenPart()->accept( *visitor );
     844                ifStmt->get_thenPart()->accept( *this );
    867845
    868846                if ( ifStmt->get_elsePart() != 0) {
    869847                        output << " else ";
    870                         ifStmt->get_elsePart()->accept( *visitor );
    871                 } // if
    872         }
    873 
    874         void CodeGenerator::postvisit( SwitchStmt * switchStmt ) {
     848                        ifStmt->get_elsePart()->accept( *this );
     849                } // if
     850        }
     851
     852        void CodeGenerator::visit( SwitchStmt * switchStmt ) {
     853                updateLocation( switchStmt );
    875854                output << "switch ( " ;
    876                 switchStmt->get_condition()->accept( *visitor );
     855                switchStmt->get_condition()->accept( *this );
    877856                output << " ) ";
    878857
    879                 output << "{" << endl;
     858                output << "{" << std::endl;
    880859                ++indent;
    881                 acceptAll( switchStmt->get_statements(), *visitor );
     860                acceptAll( switchStmt->get_statements(), *this );
    882861                --indent;
    883862                output << indent << "}";
    884863        }
    885864
    886         void CodeGenerator::postvisit( CaseStmt * caseStmt ) {
     865        void CodeGenerator::visit( CaseStmt * caseStmt ) {
     866                updateLocation( caseStmt );
     867                output << indent;
    887868                if ( caseStmt->isDefault()) {
    888869                        output << "default";
    889870                } else {
    890871                        output << "case ";
    891                         caseStmt->get_condition()->accept( *visitor );
    892                 } // if
    893                 output << ":" << endl;
     872                        caseStmt->get_condition()->accept( *this );
     873                } // if
     874                output << ":\n";
    894875
    895876                std::list<Statement *> sts = caseStmt->get_statements();
    … …  
    898879                for ( std::list<Statement *>::iterator i = sts.begin(); i != sts.end();  i++) {
    899880                        output << indent << printLabels( (*i)->get_labels() )  ;
    900                         (*i)->accept( *visitor );
     881                        (*i)->accept( *this );
    901882                        output << endl;
    902883                } // for
    … …  
    904885        }
    905886
    906         void CodeGenerator::postvisit( BranchStmt * branchStmt ) {
     887        void CodeGenerator::visit( BranchStmt * branchStmt ) {
    907888                switch ( branchStmt->get_type()) {
    908889                  case BranchStmt::Goto:
    … …  
    912893                                if ( branchStmt->get_computedTarget() != 0 ) {
    913894                                        output << "goto *";
    914                                         branchStmt->get_computedTarget()->accept( *visitor );
     895                                        branchStmt->get_computedTarget()->accept( *this );
    915896                                } // if
    916897                        } // if
    … …  
    926907        }
    927908
    928         void CodeGenerator::postvisit( ReturnStmt * returnStmt ) {
     909        void CodeGenerator::visit( ReturnStmt * returnStmt ) {
    929910                output << "return ";
    930                 maybeAccept( returnStmt->get_expr(), *visitor );
     911                maybeAccept( returnStmt->get_expr(), *this );
    931912                output << ";";
    932913        }
    933914
    934         void CodeGenerator::postvisit( ThrowStmt * throwStmt ) {
     915        void CodeGenerator::visit( ThrowStmt * throwStmt ) {
    935916                assertf( ! genC, "Throw statements should not reach code generation." );
    936917
    … …  
    939920                if (throwStmt->get_expr()) {
    940921                        output << " ";
    941                         throwStmt->get_expr()->accept( *visitor );
     922                        throwStmt->get_expr()->accept( *this );
    942923                }
    943924                if (throwStmt->get_target()) {
    944925                        output << " _At ";
    945                         throwStmt->get_target()->accept( *visitor );
     926                        throwStmt->get_target()->accept( *this );
    946927                }
    947928                output << ";";
    948929        }
    949930
    950         void CodeGenerator::postvisit( WhileStmt * whileStmt ) {
     931        void CodeGenerator::visit( WhileStmt * whileStmt ) {
    951932                if ( whileStmt->get_isDoWhile() ) {
    952933                        output << "do" ;
    953934                } else {
    954935                        output << "while (" ;
    955                         whileStmt->get_condition()->accept( *visitor );
     936                        whileStmt->get_condition()->accept( *this );
    956937                        output << ")";
    957938                } // if
    … …  
    959940
    960941                output << CodeGenerator::printLabels( whileStmt->get_body()->get_labels() );
    961                 whileStmt->get_body()->accept( *visitor );
     942                whileStmt->get_body()->accept( *this );
    962943
    963944                output << indent;
    … …  
    965946                if ( whileStmt->get_isDoWhile() ) {
    966947                        output << " while (" ;
    967                         whileStmt->get_condition()->accept( *visitor );
     948                        whileStmt->get_condition()->accept( *this );
    968949                        output << ");";
    969950                } // if
    970951        }
    971952
    972         void CodeGenerator::postvisit( ForStmt * forStmt ) {
     953        void CodeGenerator::visit( ForStmt * forStmt ) {
    973954                // initialization is always hoisted, so don't bother doing anything with that
    974955                output << "for (;";
    975956
    976957                if ( forStmt->get_condition() != 0 ) {
    977                         forStmt->get_condition()->accept( *visitor );
     958                        forStmt->get_condition()->accept( *this );
    978959                } // if
    979960                output << ";";
    … …  
    982963                        // cast the top-level expression to void to reduce gcc warnings.
    983964                        Expression * expr = new CastExpr( forStmt->get_increment() );
    984                         expr->accept( *visitor );
     965                        expr->accept( *this );
    985966                } // if
    986967                output << ") ";
    … …  
    988969                if ( forStmt->get_body() != 0 ) {
    989970                        output << CodeGenerator::printLabels( forStmt->get_body()->get_labels() );
    990                         forStmt->get_body()->accept( *visitor );
    991                 } // if
    992         }
    993 
    994         void CodeGenerator::postvisit( __attribute__((unused)) NullStmt * nullStmt ) {
     971                        forStmt->get_body()->accept( *this );
     972                } // if
     973        }
     974
     975        void CodeGenerator::visit( __attribute__((unused)) NullStmt * nullStmt ) {
    995976                //output << indent << CodeGenerator::printLabels( nullStmt->get_labels() );
    996977                output << "/* null statement */ ;";
    997978        }
    998979
    999         void CodeGenerator::postvisit( DeclStmt * declStmt ) {
    1000                 declStmt->get_decl()->accept( *visitor );
     980        void CodeGenerator::visit( DeclStmt * declStmt ) {
     981                declStmt->get_decl()->accept( *this );
    1001982
    1002983                if ( doSemicolon( declStmt->get_decl() ) ) {
    1003984                        output << ";";
    1004985                } // if
    1005         }
    1006 
    1007         void CodeGenerator::postvisit( ImplicitCtorDtorStmt * stmt ) {
    1008                 assertf( ! genC, "ImplicitCtorDtorStmts should not reach code generation." );
    1009                 stmt->callStmt->accept( *visitor );
    1010986        }
    1011987
    … …  
    10251001        }
    10261002} // namespace CodeGen
     1003
     1004std::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}
    10271012
    10281013// Local Variables: //
Note: See TracChangeset for help on using the changeset viewer.