Changes in / [e3987770:8731d8c]


Ignore:
Location:
src
Files:
9 edited

Legend:

Unmodified
Added
Removed

  • src/CodeGen/CodeGenerator.cc

    re3987770 r8731d8c  
    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 );
    … …  
    172171        }
    173172
    174         void CodeGenerator::handleAggregate( AggregateDecl * aggDecl, const std::string & kind ) {
     173        void CodeGenerator::handleAggregate( AggregateDecl * aggDecl ) {
    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 
    184                 output << kind;
    185176                if ( aggDecl->get_name() != "" )
    186177                        output << aggDecl->get_name();
    187178
     179                // std::list< Declaration * > & memb = aggDecl->get_members();
     180                // if ( ! memb.empty() ) {
    188181                if ( aggDecl->has_body() ) {
    189182                        std::list< Declaration * > & memb = aggDecl->get_members();
    … …  
    205198        void CodeGenerator::visit( StructDecl * structDecl ) {
    206199                extension( structDecl );
    207                 handleAggregate( structDecl, "struct " );
     200                output << "struct ";
     201                handleAggregate( structDecl );
    208202        }
    209203
    210204        void CodeGenerator::visit( UnionDecl * unionDecl ) {
    211205                extension( unionDecl );
    212                 handleAggregate( unionDecl, "union " );
     206                output << "union ";
     207                handleAggregate( unionDecl );
    213208        }
    214209
    … …  
    247242
    248243        void CodeGenerator::visit( TypedefDecl * typeDecl ) {
    249                 assertf( ! genC, "Typedefs are removed and substituted in earlier passes." );
    250                 output << "typedef ";
    251                 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 );
    252247        }
    253248
    254249        void CodeGenerator::visit( TypeDecl * typeDecl ) {
    255                 if ( genC ) {
    256                         // really, we should mutate this into something that isn't a TypeDecl but that requires large-scale changes,
    257                         // still to be done
    258                         extension( typeDecl );
    259                         output << "extern unsigned long " << typeDecl->get_name();
    260                         if ( typeDecl->get_base() ) {
    261                                 output << " = sizeof( " << genType( typeDecl->get_base(), "", pretty, genC ) << " )";
    262                         } // if
    263                 } else {
    264                         output << typeDecl->typeString() << " " << typeDecl->get_name();
    265                         if ( ! typeDecl->get_assertions().empty() ) {
    266                                 output << " | { ";
    267                                 genCommaList( typeDecl->get_assertions().begin(), typeDecl->get_assertions().end() );
    268                                 output << " }";
    269                         }
    270                 }
     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
    271257        }
    272258
    … …  
    307293
    308294        void CodeGenerator::visit( ConstructorInit * init ){
    309                 assertf( ! genC, "ConstructorInit nodes should not reach code generation." );
    310                 // xxx - generate something reasonable for constructor/destructor pairs
    311                 output << "<ctorinit>";
     295                assertf( false, "ConstructorInit nodes should not make it to CodeGen." );
    312296        }
    313297
    … …  
    563547                        // at least one result type of cast, but not an lvalue
    564548                        output << "(";
    565                         output << genType( castExpr->get_result(), "", pretty, genC );
     549                        output << genType( castExpr->get_result(), "", pretty );
    566550                        output << ")";
    567551                } else {
    … …  
    574558
    575559        void CodeGenerator::visit( UntypedMemberExpr * memberExpr ) {
    576                 assertf( ! genC, "UntypedMemberExpr should not reach code generation." );
    577                 extension( memberExpr );
    578                 memberExpr->get_aggregate()->accept( *this );
    579                 output << ".";
    580                 memberExpr->get_member()->accept( *this );
     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        }

  • src/CodeGen/CodeGenerator.h

    re3987770 r8731d8c  
    3030                static int tabsize;
    3131
    32                 CodeGenerator( std::ostream &os, bool pretty = false, bool genC = false );
     32                CodeGenerator( std::ostream &os, bool pretty = false );
    3333                CodeGenerator( std::ostream &os, std::string, int indent = 0, bool infun = false );
    3434                CodeGenerator( std::ostream &os, char *, int indent = 0, bool infun = false );
    … …  
    121121                LabelPrinter printLabels;
    122122                bool pretty = false;  // pretty print
    123                 bool genC = false;    // true if output has to be C code
    124123
    125124                void printDesignators( std::list< Expression * > & );
    126125                void handleStorageClass( DeclarationWithType *decl );
    127                 void handleAggregate( AggregateDecl *aggDecl, const std::string & kind );
     126                void handleAggregate( AggregateDecl *aggDecl );
    128127                void handleTypedef( NamedTypeDecl *namedType );
    129128                std::string mangleName( DeclarationWithType * decl );

  • src/CodeGen/GenType.cc

    re3987770 r8731d8c  
    2828        class GenType : public Visitor {
    2929          public:
    30                 GenType( const std::string &typeString, bool pretty = false, bool genC = false );
     30                GenType( const std::string &typeString, bool pretty = false );
    3131                std::string get_typeString() const { return typeString; }
    3232                void set_typeString( const std::string &newValue ) { typeString = newValue; }
    … …  
    4848          private:
    4949                void handleQualifiers( Type *type );
    50                 std::string handleGeneric( ReferenceToType * refType );
    5150                void genArray( const Type::Qualifiers &qualifiers, Type *base, Expression *dimension, bool isVarLen, bool isStatic );
    5251
    5352                std::string typeString;
    5453                bool pretty = false; // pretty print
    55                 bool genC = false;   // generating C code?
    5654        };
    5755
    58         std::string genType( Type *type, const std::string &baseString, bool pretty, bool genC ) {
    59                 GenType gt( baseString, pretty, genC );
     56        std::string genType( Type *type, const std::string &baseString, bool pretty ) {
     57                GenType gt( baseString, pretty );
    6058                std::ostringstream os;
    6159
    6260                if ( ! type->get_attributes().empty() ) {
    63                         CodeGenerator cg( os, pretty, genC );
     61                        CodeGenerator cg( os, pretty );
    6462                        cg.genAttributes( type->get_attributes() );
    6563                } // if
    … …  
    7068
    7169  std::string genPrettyType( Type * type, const std::string & baseString ) {
    72         return genType( type, baseString, true, false );
     70        return genType( type, baseString, true );
    7371  }
    7472
    75         GenType::GenType( const std::string &typeString, bool pretty, bool genC ) : typeString( typeString ), pretty( pretty ), genC( genC ) {}
     73        GenType::GenType( const std::string &typeString, bool pretty ) : typeString( typeString ), pretty( pretty ) {}
    7674
    7775        void GenType::visit( VoidType *voidType ) {
    … …  
    114112                } // if
    115113                if ( dimension != 0 ) {
    116                         CodeGenerator cg( os, pretty, genC );
     114                        CodeGenerator cg( os, pretty );
    117115                        dimension->accept( cg );
    118116                } else if ( isVarLen ) {
    … …  
    168166                        } // if
    169167                } else {
    170                         CodeGenerator cg( os, pretty, genC );
     168                        CodeGenerator cg( os, pretty );
    171169                        os << "(" ;
    172170
    … …  
    186184                        funcType->get_returnVals().front()->get_type()->accept( *this );
    187185                } // if
    188 
    189                 // add forall
    190                 if( ! funcType->get_forall().empty() && ! genC ) {
    191                         // assertf( ! genC, "Aggregate type parameters should not reach code generation." );
    192                         std::ostringstream os;
    193                         CodeGenerator cg( os, pretty, genC );
    194                         os << "forall(";
    195                         cg.genCommaList( funcType->get_forall().begin(), funcType->get_forall().end() );
    196                         os << ")" << std::endl;
    197                         typeString = os.str() + typeString;
    198                 }
    199         }
    200 
    201         std::string GenType::handleGeneric( ReferenceToType * refType ) {
    202                 if ( ! refType->get_parameters().empty() ) {
    203                         std::ostringstream os;
    204                         CodeGenerator cg( os, pretty, genC );
    205                         os << "(";
    206                         cg.genCommaList( refType->get_parameters().begin(), refType->get_parameters().end() );
    207                         os << ") ";
    208                         return os.str();
    209                 }
    210                 return "";
    211186        }
    212187
    213188        void GenType::visit( StructInstType *structInst )  {
    214                 typeString = structInst->get_name() + handleGeneric( structInst ) + " " + typeString;
    215                 if ( genC ) typeString = "struct " + typeString;
     189                typeString = "struct " + structInst->get_name() + " " + typeString;
    216190                handleQualifiers( structInst );
    217191        }
    218192
    219193        void GenType::visit( UnionInstType *unionInst ) {
    220                 typeString = unionInst->get_name() + handleGeneric( unionInst ) + " " + typeString;
    221                 if ( genC ) typeString = "union " + typeString;
     194                typeString = "union " + unionInst->get_name() + " " + typeString;
    222195                handleQualifiers( unionInst );
    223196        }
    224197
    225198        void GenType::visit( EnumInstType *enumInst ) {
    226                 typeString = enumInst->get_name() + " " + typeString;
    227                 if ( genC ) typeString = "enum " + typeString;
     199                typeString = "enum " + enumInst->get_name() + " " + typeString;
    228200                handleQualifiers( enumInst );
    229201        }
    … …  
    235207
    236208        void GenType::visit( TupleType * tupleType ) {
    237                 assertf( ! genC, "Tuple types should not reach code generation." );
     209                assertf( pretty, "Tuple types should not make it to Code Gen." );
    238210                Visitor::visit( tupleType );
    239211                unsigned int i = 0;
    … …  
    242214                for ( Type * t : *tupleType ) {
    243215                        i++;
    244                         os << genType( t, "", pretty, genC ) << (i == tupleType->size() ? "" : ", ");
     216                        os << genType( t, "", pretty ) << (i == tupleType->size() ? "" : ", ");
    245217                }
    246218                os << "]";

  • src/CodeGen/GenType.h

    re3987770 r8731d8c  
    2121
    2222namespace CodeGen {
    23         std::string genType( Type *type, const std::string &baseString, bool pretty = false, bool genC = false );
     23        std::string genType( Type *type, const std::string &baseString, bool pretty = false );
    2424  std::string genPrettyType( Type * type, const std::string & baseString );
    2525} // namespace CodeGen

  • src/CodeGen/Generate.cc

    re3987770 r8731d8c  
    2727
    2828namespace CodeGen {
    29         void generate( std::list< Declaration* > translationUnit, std::ostream &os, bool doIntrinsics, bool pretty, bool generateC ) {
    30                 CodeGen::CodeGenerator cgv( os, pretty, generateC );
     29        void generate( std::list< Declaration* > translationUnit, std::ostream &os, bool doIntrinsics, bool pretty ) {
     30                CodeGen::CodeGenerator cgv( os, pretty );
    3131                for ( auto & dcl : translationUnit ) {
    3232                        if ( LinkageSpec::isGeneratable( dcl->get_linkage() ) && (doIntrinsics || ! LinkageSpec::isBuiltin( dcl->get_linkage() ) ) ) {

  • src/CodeGen/Generate.h

    re3987770 r8731d8c  
    2323
    2424namespace CodeGen {
    25         /// Generates code. doIntrinsics determines if intrinsic functions are printed, pretty formats output nicely (e.g., uses unmangled names, etc.), generateC is true when the output must consist only of C code (allows some assertions, etc.)
    26         void generate( std::list< Declaration* > translationUnit, std::ostream &os, bool doIntrinsics, bool pretty, bool generateC = false );
     25        /// Generates code
     26        void generate( std::list< Declaration* > translationUnit, std::ostream &os, bool doIntrinsics, bool pretty );
    2727} // namespace CodeGen
    2828

  • src/SynTree/Declaration.h

    re3987770 r8731d8c  
    167167        std::list< DeclarationWithType* >& get_assertions() { return assertions; }
    168168
     169        virtual NamedTypeDecl *clone() const = 0;
     170        virtual void print( std::ostream &os, int indent = 0 ) const;
     171        virtual void printShort( std::ostream &os, int indent = 0 ) const;
     172  protected:
    169173        virtual std::string typeString() const = 0;
    170 
    171         virtual NamedTypeDecl *clone() const = 0;
    172         virtual void print( std::ostream &os, int indent = 0 ) const;
    173         virtual void printShort( std::ostream &os, int indent = 0 ) const;
    174   protected:
    175174  private:
    176175        Type *base;
    … …  
    203202        TypeDecl * set_sized( bool newValue ) { sized = newValue; return this; }
    204203
    205         virtual std::string typeString() const;
    206 
    207204        virtual TypeDecl *clone() const { return new TypeDecl( *this ); }
    208205        virtual void accept( Visitor &v ) { v.visit( this ); }
    209206        virtual TypeDecl *acceptMutator( Mutator &m ) { return m.mutate( this ); }
    210207  private:
     208        virtual std::string typeString() const;
    211209        Kind kind;
    212210        bool sized;
    … …  
    219217        TypedefDecl( const TypedefDecl &other ) : Parent( other ) {}
    220218
    221         virtual std::string typeString() const;
    222 
    223219        virtual TypedefDecl *clone() const { return new TypedefDecl( *this ); }
    224220        virtual void accept( Visitor &v ) { v.visit( this ); }
    225221        virtual Declaration *acceptMutator( Mutator &m ) { return m.mutate( this ); }
    226222  private:
     223        virtual std::string typeString() const;
    227224};
    228225

  • src/main.cc

    re3987770 r8731d8c  
    304304                GenPoly::box( translationUnit );
    305305
     306                // print tree right before code generation
     307                if ( codegenp ) {
     308                        dump( translationUnit );
     309                        return 0;
     310                } // if
     311
    306312                if ( optind < argc ) {                                                  // any commands after the flags and input file ? => output file name
    307313                        output = new ofstream( argv[ optind ] );
    308314                } // if
    309315
    310                 CodeGen::generate( translationUnit, *output, ! noprotop, prettycodegenp, true );
     316                CodeGen::generate( translationUnit, *output, ! noprotop, prettycodegenp );
    311317
    312318                CodeGen::FixMain::fix( *output, treep ? "../prelude/bootloader.c" : CFA_LIBDIR "/bootloader.c" );
    … …  
    387393                        break;
    388394                  case CtorInitFix:
    389                   case 'c':                                                                             // print after constructors and destructors are replaced
     395                  case 'c':
    390396                        ctorinitp = true;
    391397                        break;
    … …  
    444450                        validp = true;
    445451                        break;
    446                   case 'y':                                                                             // dump AST on error
     452                  case 'y':
    447453                        errorp = true;
    448454                        break;
    449                   case 'z':                                                                             // dump as codegen rather than AST
     455                  case 'z':
    450456                        codegenp = true;
    451                         break;
    452                         case 'Z':                                                                       // prettyprint during codegen (i.e. print unmangled names, etc.)
     457                        case 'Z':
    453458                        prettycodegenp = true;
    454459                        break;
    … …  
    496501        } // if
    497502
    498         // depending on commandline options, either generate code or dump the AST
    499         if ( codegenp ) {
    500                 CodeGen::generate( decls, out, ! noprotop, prettycodegenp );
    501         } else {
    502                 printAll( decls, out );
    503         }
     503        printAll( decls, out );
    504504        deleteAll( translationUnit );
    505505} // dump

  • src/tests/.expect/memberCtors-ERR1.txt

    re3987770 r8731d8c  
    1 memberCtors.c:62 error: in void ?{}(B *b), field a2 used before being constructed
     1memberCtors.c:62 error: in void ?{}(struct B *b), field a2 used before being constructed
    22make: *** [memberCtors-ERR1] Error 1
Note: See TracChangeset for help on using the changeset viewer.