Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed
  • src/CodeGen/CodeGenerator.cc

    re39241b rfbcde64  
    8989        }
    9090
    91         CodeGenerator::CodeGenerator( std::ostream & os, bool pretty, bool genC ) : indent( *this), cur_indent( 0 ), insideFunction( false ), output( os ), printLabels( *this ), pretty( pretty ), genC( genC ) {}
     91        CodeGenerator::CodeGenerator( std::ostream & os, bool pretty ) : indent( *this), cur_indent( 0 ), insideFunction( false ), output( os ), printLabels( *this ), pretty( pretty ) {}
    9292
    9393        CodeGenerator::CodeGenerator( std::ostream & os, std::string init, int indentation, bool infunp )
     
    136136                functionDecl->get_funcSpec().print( output );
    137137
    138                 output << genType( functionDecl->get_functionType(), mangleName( functionDecl ), pretty, genC );
     138                output << genType( functionDecl->get_functionType(), mangleName( functionDecl ), pretty );
    139139
    140140                asmName( functionDecl );
     
    147147
    148148        void CodeGenerator::visit( ObjectDecl * objectDecl ) {
    149                 if (objectDecl->get_name().empty() && genC ) {
    150                         // only generate an anonymous name when generating C code, otherwise it clutters the output too much
     149                if (objectDecl->get_name().empty()) {
    151150                        static UniqueName name = { "__anonymous_object" };
    152151                        objectDecl->set_name( name.newName() );
     
    157156
    158157                handleStorageClass( objectDecl );
    159                 output << genType( objectDecl->get_type(), mangleName( objectDecl ), pretty, genC );
     158                output << genType( objectDecl->get_type(), mangleName( objectDecl ), pretty );
    160159
    161160                asmName( objectDecl );
     
    175174                genAttributes( aggDecl->get_attributes() );
    176175
    177                 if( ! aggDecl->get_parameters().empty() && ! genC ) {
    178                         // assertf( ! genC, "Aggregate type parameters should not reach code generation." );
    179                         output << "forall(";
    180                         genCommaList( aggDecl->get_parameters().begin(), aggDecl->get_parameters().end() );
    181                         output << ")" << endl;
    182                 }
    183 
    184176                if ( aggDecl->get_name() != "" )
    185177                        output << aggDecl->get_name();
    186178
     179                // std::list< Declaration * > & memb = aggDecl->get_members();
     180                // if ( ! memb.empty() ) {
    187181                if ( aggDecl->has_body() ) {
    188182                        std::list< Declaration * > & memb = aggDecl->get_members();
     
    248242
    249243        void CodeGenerator::visit( TypedefDecl * typeDecl ) {
    250                 assertf( ! genC, "Typedefs are removed and substituted in earlier passes." );
    251                 output << "typedef ";
    252                 output << genType( typeDecl->get_base(), typeDecl->get_name(), pretty, genC ) << endl;
     244                assert( false && "Typedefs are removed and substituted in earlier passes." );
     245                //output << "typedef ";
     246                //output << genType( typeDecl->get_base(), typeDecl->get_name(), pretty );
    253247        }
    254248
    255249        void CodeGenerator::visit( TypeDecl * typeDecl ) {
    256                 if ( genC ) {
    257                         // really, we should mutate this into something that isn't a TypeDecl but that requires large-scale changes,
    258                         // still to be done
    259                         extension( typeDecl );
    260                         output << "extern unsigned long " << typeDecl->get_name();
    261                         if ( typeDecl->get_base() ) {
    262                                 output << " = sizeof( " << genType( typeDecl->get_base(), "", pretty, genC ) << " )";
    263                         } // if
    264                 } else {
    265                         output << typeDecl->typeString() << " " << typeDecl->get_name();
    266                         if ( ! typeDecl->get_assertions().empty() ) {
    267                                 output << " | { ";
    268                                 genCommaList( typeDecl->get_assertions().begin(), typeDecl->get_assertions().end() );
    269                                 output << " }";
    270                         }
    271                 }
     250                // really, we should mutate this into something that isn't a TypeDecl but that requires large-scale changes,
     251                // still to be done
     252                extension( typeDecl );
     253                output << "extern unsigned long " << typeDecl->get_name();
     254                if ( typeDecl->get_base() ) {
     255                        output << " = sizeof( " << genType( typeDecl->get_base(), "", pretty ) << " )";
     256                } // if
    272257        }
    273258
     
    308293
    309294        void CodeGenerator::visit( ConstructorInit * init ){
    310                 assertf( ! genC, "ConstructorInit nodes should not reach code generation." );
    311                 // xxx - generate something reasonable for constructor/destructor pairs
    312                 output << "<ctorinit>";
     295                assertf( false, "ConstructorInit nodes should not make it to CodeGen." );
    313296        }
    314297
     
    564547                        // at least one result type of cast, but not an lvalue
    565548                        output << "(";
    566                         output << genType( castExpr->get_result(), "", pretty, genC );
     549                        output << genType( castExpr->get_result(), "", pretty );
    567550                        output << ")";
    568551                } else {
     
    575558
    576559        void CodeGenerator::visit( UntypedMemberExpr * memberExpr ) {
    577                 assertf( ! genC, "UntypedMemberExpr should not reach code generation." );
    578                 extension( memberExpr );
    579                 memberExpr->get_aggregate()->accept( *this );
    580                 output << "." << memberExpr->get_member();
     560                assert( false );
    581561        }
    582562
     
    607587                output << "sizeof(";
    608588                if ( sizeofExpr->get_isType() ) {
    609                         output << genType( sizeofExpr->get_type(), "", pretty, genC );
     589                        output << genType( sizeofExpr->get_type(), "", pretty );
    610590                } else {
    611591                        sizeofExpr->get_expr()->accept( *this );
     
    619599                output << "__alignof__(";
    620600                if ( alignofExpr->get_isType() ) {
    621                         output << genType( alignofExpr->get_type(), "", pretty, genC );
     601                        output << genType( alignofExpr->get_type(), "", pretty );
    622602                } else {
    623603                        alignofExpr->get_expr()->accept( *this );
     
    627607
    628608        void CodeGenerator::visit( UntypedOffsetofExpr * offsetofExpr ) {
    629                 assertf( ! genC, "UntypedOffsetofExpr should not reach code generation." );
    630                 output << "offsetof(";
    631                 output << genType( offsetofExpr->get_type(), "", pretty, genC );
    632                 output << ", " << offsetofExpr->get_member();
    633                 output << ")";
     609                assert( false && "UntypedOffsetofExpr should not reach code generation." );
    634610        }
    635611
     
    637613                // use GCC builtin
    638614                output << "__builtin_offsetof(";
    639                 output << genType( offsetofExpr->get_type(), "", pretty, genC );
     615                output << genType( offsetofExpr->get_type(), "", pretty );
    640616                output << ", " << mangleName( offsetofExpr->get_member() );
    641617                output << ")";
     
    643619
    644620        void CodeGenerator::visit( OffsetPackExpr * offsetPackExpr ) {
    645                 assertf( ! genC, "OffsetPackExpr should not reach code generation." );
    646                 output << "__CFA_offsetpack(" << genType( offsetPackExpr->get_type(), "", pretty, genC ) << ")";
     621                assert( false && "OffsetPackExpr should not reach code generation." );
    647622        }
    648623
     
    680655        }
    681656
    682         void CodeGenerator::visit( UntypedTupleExpr * tupleExpr ) {
    683                 assertf( ! genC, "UntypedTupleExpr should not reach code generation." );
    684                 output << "[";
    685                 genCommaList( tupleExpr->get_exprs().begin(), tupleExpr->get_exprs().end() );
    686                 output << "]";
    687         }
    688 
    689         void CodeGenerator::visit( TupleExpr * tupleExpr ) {
    690                 assertf( ! genC, "TupleExpr should not reach code generation." );
    691                 output << "[";
    692                 genCommaList( tupleExpr->get_exprs().begin(), tupleExpr->get_exprs().end() );
    693                 output << "]";
    694         }
    695 
    696         void CodeGenerator::visit( TypeExpr * typeExpr ) {
    697                 assertf( ! genC, "TypeExpr should not reach code generation." );
    698                 output<< genType( typeExpr->get_type(), "", pretty, genC );
    699         }
     657        void CodeGenerator::visit( UntypedTupleExpr * tupleExpr ) { assertf( false, "UntypedTupleExpr should not make it to Code Gen" ); }
     658
     659        void CodeGenerator::visit( TupleExpr * tupleExpr ) { assertf( false, "TupleExpr should not make it to Code Gen" ); }
     660
     661        void CodeGenerator::visit( TypeExpr * typeExpr ) {}
    700662
    701663        void CodeGenerator::visit( AsmExpr * asmExpr ) {
     
    713675        void CodeGenerator::visit( CompoundLiteralExpr *compLitExpr ) {
    714676                assert( compLitExpr->get_result() && dynamic_cast< ListInit * > ( compLitExpr->get_initializer() ) );
    715                 output << "(" << genType( compLitExpr->get_result(), "", pretty, genC ) << ")";
     677                output << "(" << genType( compLitExpr->get_result(), "", pretty ) << ")";
    716678                compLitExpr->get_initializer()->accept( *this );
    717679        }
Note: See TracChangeset for help on using the changeset viewer.